@woosh/meep-engine 3.49.0 → 3.50.0

package/src/shade/renderer/shader/chunk/geometry/vec3/chunk_v3_slerp.js

@@ -0,0 +1,86 @@
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+import { PI_DECLARATION } from "../../math/PI_DECLARATION.js";
+import { chunk_v3_angle_stable } from "./chunk_v3_angle_stable.js";
+
+/**
+ * Spherical linear interpolation between two unit vectors, `fraction` ≥ 0.
+ *
+ * The WGSL twin of `v3_slerp` (`core/geom/vec3/v3_slerp.js`), branch for branch, so the two agree
+ * everywhere, including the cases where the answer is a choice:
+ * - **Same direction** (`dot ≥ 1`): a lerp, which stays on the sphere.
+ * - **Antipodal** (`dot ≤ −1 + 1e-7`): no unique arc. The endpoints come back exactly at fraction 0
+ *   and 1. Between them the arc runs through `a` crossed with the principal axis `a` is least aligned
+ *   with, the same perpendicular `v3_slerp` picks, at angle `fraction·π`.
+ * - **Otherwise** the general formula, `sin((1 − f)θ)/sin θ · a + sin(fθ)/sin θ · b`. Close to
+ *   parallel, `θ` is small but `sin θ` is not zero, so the formula holds.
+ *
+ * One departure, in precision only. `θ` comes from {@link chunk_v3_angle_stable},
+ * `atan2(‖a × b‖, a·b)`, where `v3_slerp` takes `acos(a·b)`. For unit vectors the two are the same
+ * angle. In f32, though, `acos` next to the antipode moves by `6e-8/sin θ`, and the formula divides by
+ * `sin θ` again. Measured against the JS on exact directions, rounded to f32 for the device, 1e-3 rad
+ * short of opposite: 1.7e-2 with `acos`, 5.7e-5 with `atan2`. The bound is f32's ulp of `θ` there over
+ * `sin θ`, 9.5e-4.
+ *
+ * One residual, measured. Where the dot is within f32's resolution of the antipodal threshold, about
+ * 4.5e-4 rad short of opposite, the device and the CPU can round to different branches. They then turn
+ * through different planes.
+ *
+ * @see https://en.wikipedia.org/wiki/Slerp
+ * @type {CodeChunk}
+ */
+export const chunk_v3_slerp = CodeChunk.from(
+    //language=WGSL
+    `
+fn v3_slerp(a: vec3<f32>, b: vec3<f32>, fraction: f32) -> vec3<f32> {
+    let d = dot(a, b);
+
+    if (d >= 1.0) {
+        // the arc has no length, and a lerp stays on the sphere
+        return (b - a) * fraction + a;
+    }
+
+    if (d <= -1.0 + 1e-7) {
+        // antipodal: the endpoints exactly, and between them any perpendicular to a will do
+        if (fraction <= 0.0) {
+            return a;
+        }
+
+        if (fraction >= 1.0) {
+            return b;
+        }
+
+        // a crossed with the principal axis it is least aligned with, which is well conditioned
+        let a_abs = abs(a);
+
+        var o: vec3<f32>;
+
+        if (a_abs.x <= a_abs.y && a_abs.x <= a_abs.z) {
+            o = vec3(0.0, -a.z, a.y);
+        } else if (a_abs.y <= a_abs.z) {
+            o = vec3(-a.z, 0.0, a.x);
+        } else {
+            o = vec3(-a.y, a.x, 0.0);
+        }
+
+        o = o * (1.0 / length(o));
+
+        let angle = PI * fraction;
+
+        return a * cos(angle) + o * sin(angle);
+    }
+
+    // v3_slerp takes acos(d): the same angle for unit vectors, but in f32 acos moves by 6e-8 / sin(theta) next to the antipode, and the formula divides by sin(theta) again
+    let theta = v3_angle_stable(a, b);
+
+    let inverse_sin_theta = 1.0 / sin(theta);
+
+    let scale_0 = sin((1.0 - fraction) * theta) * inverse_sin_theta;
+    let scale_1 = sin(fraction * theta) * inverse_sin_theta;
+
+    return a * scale_0 + b * scale_1;
+}
+    `, [
+        PI_DECLARATION,
+        chunk_v3_angle_stable,
+    ]
+);

package/src/shade/renderer/shader/chunk/grid/GRID_TILE_WINDOW_STRUCT.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Where a window of a toroidally stored 3-D grid sits, for {@link chunk_grid_tile_halo_f32} and
+ * {@link chunk_grid_tile_halo_vec4}.
+ *
+ * A grid cell is addressed three ways. Its **world cell** is its integer coordinate on the grid's
+ * own lattice, unbounded. Its **window-local** cell is the world cell minus `corner`, in
+ * `[0, size)` on every axis when it is inside the window. Its **storage cell** is the world cell
+ * modulo `period` per axis, which is where the grid keeps it: a window that scrolls rewrites only
+ * the slots it exposes.
+ *
+ * - `corner`: the world cell at window-local (0, 0, 0).
+ * - `corner_storage`: `corner` modulo `period`, each axis in `[0, period)`. The caller computes it
+ *   once (the CPU window bookkeeping knows it), so the per-cell maths is one conditional subtract
+ *   and no `%`.
+ * - `size`: cells the window holds on each axis, at most `period`, so that no two cells inside
+ *   share a slot.
+ * - `period`: storage period on each axis. Periods may differ by axis and may be odd: a MAC face
+ *   grid of N cells stores N + 1 faces along its own axis.
+ *
+ * @type {WebGPUStruct}
+ */
+export const GRID_TILE_WINDOW_STRUCT: WebGPUStruct;
+import { WebGPUStruct } from "../../type/WebGPUStruct.js";
+//# sourceMappingURL=GRID_TILE_WINDOW_STRUCT.d.ts.map

package/src/shade/renderer/shader/chunk/grid/GRID_TILE_WINDOW_STRUCT.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GRID_TILE_WINDOW_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/grid/GRID_TILE_WINDOW_STRUCT.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,sCAFU,YAAY,CAOD;6BA5BQ,4BAA4B"}

package/src/shade/renderer/shader/chunk/grid/GRID_TILE_WINDOW_STRUCT.js

@@ -0,0 +1,30 @@
+import { vec3i, vec3u } from "../../type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../type/WebGPUStruct.js";
+
+/**
+ * Where a window of a toroidally stored 3-D grid sits, for {@link chunk_grid_tile_halo_f32} and
+ * {@link chunk_grid_tile_halo_vec4}.
+ *
+ * A grid cell is addressed three ways. Its **world cell** is its integer coordinate on the grid's
+ * own lattice, unbounded. Its **window-local** cell is the world cell minus `corner`, in
+ * `[0, size)` on every axis when it is inside the window. Its **storage cell** is the world cell
+ * modulo `period` per axis, which is where the grid keeps it: a window that scrolls rewrites only
+ * the slots it exposes.
+ *
+ * - `corner`: the world cell at window-local (0, 0, 0).
+ * - `corner_storage`: `corner` modulo `period`, each axis in `[0, period)`. The caller computes it
+ *   once (the CPU window bookkeeping knows it), so the per-cell maths is one conditional subtract
+ *   and no `%`.
+ * - `size`: cells the window holds on each axis, at most `period`, so that no two cells inside
+ *   share a slot.
+ * - `period`: storage period on each axis. Periods may differ by axis and may be odd: a MAC face
+ *   grid of N cells stores N + 1 faces along its own axis.
+ *
+ * @type {WebGPUStruct}
+ */
+export const GRID_TILE_WINDOW_STRUCT = WebGPUStruct.from({
+    corner: vec3i,
+    corner_storage: vec3u,
+    size: vec3u,
+    period: vec3u,
+}, 'GridTileWindow');

package/src/shade/renderer/shader/chunk/grid/chunk_grid_tile_halo_f32.d.ts

@@ -0,0 +1,55 @@
+/**
+ * An 8 x 8 x 4 tile of an f32 grid and its one-cell halo, loaded into workgroup memory by the
+ * whole workgroup, for stencil kernels that read each cell's neighbours many times over.
+ *
+ * ## Use
+ *
+ * The kernel declares the tile, so one kernel can hold as many as it needs:
+ *
+ *     var<workgroup> pressure: array<f32, GRID_TILE_HALO_CELLS>;
+ *
+ * and every invocation of a `GRID_TILE_THREADS`-invocation workgroup (256) calls, in uniform
+ * control flow,
+ *
+ *     grid_tile_f32_load(&pressure, window, source, tile_origin, lane);
+ *
+ * with `lane` its `local_invocation_index`, `window` a {@link GRID_TILE_WINDOW_STRUCT}, and
+ * `tile_origin` the window-local cell of the tile's first interior cell (a multiple of
+ * `GRID_TILE_SIZE` for a tile grid laid over the window). The call ends in `workgroupBarrier()`,
+ * after which `grid_tile_f32_read(&pressure, local)` reads any tile-local cell in
+ * `[-1, 8] x [-1, 8] x [-1, 4]`, and `grid_tile_f32_write` writes one (a smoother sweeping its
+ * interior against the frozen halo does both).
+ *
+ * Those two are the tile accessor the stencil maths should be written against. A kernel names
+ * one accessor per field and backs it with the tile; a spec backs the same name with a buffer, and
+ * the per-cell maths runs under the emulator unchanged:
+ *
+ *     fn tile_read_p(local: vec3<i32>) -> f32 { return grid_tile_f32_read(&pressure, local); }
+ *
+ * ## Where the values come from: two functions the enclosing shader defines
+ *
+ * The chunk binds nothing. Each of the 600 cells is classified on its own against the window, and
+ * fetched through one of two functions the shader that includes this chunk must define, in the
+ * manner of the particle VM's `vm_reg_read` and `vm_reg_write`:
+ *
+ * - `fn grid_tile_f32_fetch_inside(source: u32, storage_cell: vec3<u32>) -> f32` for a cell inside
+ *   the window, by its storage cell: already wrapped, in `[0, period)` on every axis. A storage
+ *   buffer answers with its element at that cell, an `r32float` texture with `textureLoad`.
+ * - `fn grid_tile_f32_fetch_outside(source: u32, world_cell: vec3<i32>) -> f32` for a cell outside
+ *   it, beyond the window on any side, by its world cell. The fluid answers from the parent
+ *   cascade.
+ *
+ * `source` is passed through untouched. It is how a kernel loading several tiles tells the fetch
+ * which grid it wants; a kernel with one tile ignores it. Passing a literal lets the compiler fold
+ * the fetch's choice away.
+ *
+ * ## Cost
+ *
+ * `GRID_TILE_LOAD_ROUNDS` (3) fetches and stores per invocation, then one barrier. 2400 bytes of
+ * workgroup memory per tile.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_grid_tile_halo_f32: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_grid_tile_halo_f32.d.ts.map

package/src/shade/renderer/shader/chunk/grid/chunk_grid_tile_halo_f32.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_grid_tile_halo_f32.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/grid/chunk_grid_tile_halo_f32.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,uCAFU,SAAS,CA8ChB;0BApGuB,6BAA6B"}

package/src/shade/renderer/shader/chunk/grid/chunk_grid_tile_halo_f32.js

@@ -0,0 +1,101 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+import { chunk_grid_tile_window } from "./chunk_grid_tile_window.js";
+import { GRID_TILE_WINDOW_STRUCT } from "./GRID_TILE_WINDOW_STRUCT.js";
+
+/**
+ * An 8 x 8 x 4 tile of an f32 grid and its one-cell halo, loaded into workgroup memory by the
+ * whole workgroup, for stencil kernels that read each cell's neighbours many times over.
+ *
+ * ## Use
+ *
+ * The kernel declares the tile, so one kernel can hold as many as it needs:
+ *
+ *     var<workgroup> pressure: array<f32, GRID_TILE_HALO_CELLS>;
+ *
+ * and every invocation of a `GRID_TILE_THREADS`-invocation workgroup (256) calls, in uniform
+ * control flow,
+ *
+ *     grid_tile_f32_load(&pressure, window, source, tile_origin, lane);
+ *
+ * with `lane` its `local_invocation_index`, `window` a {@link GRID_TILE_WINDOW_STRUCT}, and
+ * `tile_origin` the window-local cell of the tile's first interior cell (a multiple of
+ * `GRID_TILE_SIZE` for a tile grid laid over the window). The call ends in `workgroupBarrier()`,
+ * after which `grid_tile_f32_read(&pressure, local)` reads any tile-local cell in
+ * `[-1, 8] x [-1, 8] x [-1, 4]`, and `grid_tile_f32_write` writes one (a smoother sweeping its
+ * interior against the frozen halo does both).
+ *
+ * Those two are the tile accessor the stencil maths should be written against. A kernel names
+ * one accessor per field and backs it with the tile; a spec backs the same name with a buffer, and
+ * the per-cell maths runs under the emulator unchanged:
+ *
+ *     fn tile_read_p(local: vec3<i32>) -> f32 { return grid_tile_f32_read(&pressure, local); }
+ *
+ * ## Where the values come from: two functions the enclosing shader defines
+ *
+ * The chunk binds nothing. Each of the 600 cells is classified on its own against the window, and
+ * fetched through one of two functions the shader that includes this chunk must define, in the
+ * manner of the particle VM's `vm_reg_read` and `vm_reg_write`:
+ *
+ * - `fn grid_tile_f32_fetch_inside(source: u32, storage_cell: vec3<u32>) -> f32` for a cell inside
+ *   the window, by its storage cell: already wrapped, in `[0, period)` on every axis. A storage
+ *   buffer answers with its element at that cell, an `r32float` texture with `textureLoad`.
+ * - `fn grid_tile_f32_fetch_outside(source: u32, world_cell: vec3<i32>) -> f32` for a cell outside
+ *   it, beyond the window on any side, by its world cell. The fluid answers from the parent
+ *   cascade.
+ *
+ * `source` is passed through untouched. It is how a kernel loading several tiles tells the fetch
+ * which grid it wants; a kernel with one tile ignores it. Passing a literal lets the compiler fold
+ * the fetch's choice away.
+ *
+ * ## Cost
+ *
+ * `GRID_TILE_LOAD_ROUNDS` (3) fetches and stores per invocation, then one barrier. 2400 bytes of
+ * workgroup memory per tile.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_grid_tile_halo_f32 = CodeChunk.from(
+    //language=WGSL
+    `
+fn grid_tile_f32_load(
+    tile: ptr<workgroup, array<f32, GRID_TILE_HALO_CELLS>>,
+    window: ${GRID_TILE_WINDOW_STRUCT.wgsl_ref},
+    source: u32,
+    tile_origin: vec3<i32>,
+    lane: u32
+) {
+    for (var iteration = 0u; iteration < GRID_TILE_LOAD_ROUNDS; iteration++) {
+        let index = iteration * GRID_TILE_THREADS + lane;
+
+        if (index < GRID_TILE_HALO_CELLS) {
+            let window_local = tile_origin + grid_tile_halo_local(index);
+
+            var value: f32;
+
+            if (grid_tile_window_contains(window_local, window.size)) {
+                value = grid_tile_f32_fetch_inside(
+                    source,
+                    grid_tile_window_storage(window_local, window.corner_storage, window.period)
+                );
+            } else {
+                value = grid_tile_f32_fetch_outside(source, window.corner + window_local);
+            }
+
+            (*tile)[index] = value;
+        }
+    }
+
+    workgroupBarrier();
+}
+
+fn grid_tile_f32_read(tile: ptr<workgroup, array<f32, GRID_TILE_HALO_CELLS>>, local: vec3<i32>) -> f32 {
+    return (*tile)[grid_tile_halo_index(local)];
+}
+
+fn grid_tile_f32_write(tile: ptr<workgroup, array<f32, GRID_TILE_HALO_CELLS>>, local: vec3<i32>, value: f32) {
+    (*tile)[grid_tile_halo_index(local)] = value;
+}
+`, [
+    GRID_TILE_WINDOW_STRUCT.declaration_chunk,
+    chunk_grid_tile_window,
+]);

package/src/shade/renderer/shader/chunk/grid/chunk_grid_tile_halo_vec4.d.ts

@@ -0,0 +1,24 @@
+/**
+ * {@link chunk_grid_tile_halo_f32} for a grid of `vec4<f32>`: the same tile, halo, window and
+ * contract, with `vec4<f32>` cells and its own names, so a kernel can include both.
+ *
+ * The kernel declares `var<workgroup> name: array<vec4<f32>, GRID_TILE_HALO_CELLS>`, calls
+ * `grid_tile_vec4_load(&name, window, source, tile_origin, lane)` from every invocation of a
+ * `GRID_TILE_THREADS`-invocation workgroup in uniform control flow, and then reads and writes
+ * tile-local cells with `grid_tile_vec4_read` and `grid_tile_vec4_write`.
+ *
+ * The enclosing shader defines the two fetches:
+ *
+ * - `fn grid_tile_vec4_fetch_inside(source: u32, storage_cell: vec3<u32>) -> vec4<f32>` for a cell
+ *   inside the window, by its wrapped storage cell; typically a `textureLoad` of an `rgba` texture.
+ * - `fn grid_tile_vec4_fetch_outside(source: u32, world_cell: vec3<i32>) -> vec4<f32>` for a cell
+ *   beyond the window on any side, by its world cell.
+ *
+ * `GRID_TILE_LOAD_ROUNDS` (3) fetches and stores per invocation, then one barrier. 9600 bytes of
+ * workgroup memory per tile.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_grid_tile_halo_vec4: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_grid_tile_halo_vec4.d.ts.map

package/src/shade/renderer/shader/chunk/grid/chunk_grid_tile_halo_vec4.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_grid_tile_halo_vec4.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/grid/chunk_grid_tile_halo_vec4.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wCAFU,SAAS,CA8ChB;0BArEuB,6BAA6B"}

package/src/shade/renderer/shader/chunk/grid/chunk_grid_tile_halo_vec4.js

@@ -0,0 +1,70 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+import { chunk_grid_tile_window } from "./chunk_grid_tile_window.js";
+import { GRID_TILE_WINDOW_STRUCT } from "./GRID_TILE_WINDOW_STRUCT.js";
+
+/**
+ * {@link chunk_grid_tile_halo_f32} for a grid of `vec4<f32>`: the same tile, halo, window and
+ * contract, with `vec4<f32>` cells and its own names, so a kernel can include both.
+ *
+ * The kernel declares `var<workgroup> name: array<vec4<f32>, GRID_TILE_HALO_CELLS>`, calls
+ * `grid_tile_vec4_load(&name, window, source, tile_origin, lane)` from every invocation of a
+ * `GRID_TILE_THREADS`-invocation workgroup in uniform control flow, and then reads and writes
+ * tile-local cells with `grid_tile_vec4_read` and `grid_tile_vec4_write`.
+ *
+ * The enclosing shader defines the two fetches:
+ *
+ * - `fn grid_tile_vec4_fetch_inside(source: u32, storage_cell: vec3<u32>) -> vec4<f32>` for a cell
+ *   inside the window, by its wrapped storage cell; typically a `textureLoad` of an `rgba` texture.
+ * - `fn grid_tile_vec4_fetch_outside(source: u32, world_cell: vec3<i32>) -> vec4<f32>` for a cell
+ *   beyond the window on any side, by its world cell.
+ *
+ * `GRID_TILE_LOAD_ROUNDS` (3) fetches and stores per invocation, then one barrier. 9600 bytes of
+ * workgroup memory per tile.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_grid_tile_halo_vec4 = CodeChunk.from(
+    //language=WGSL
+    `
+fn grid_tile_vec4_load(
+    tile: ptr<workgroup, array<vec4<f32>, GRID_TILE_HALO_CELLS>>,
+    window: ${GRID_TILE_WINDOW_STRUCT.wgsl_ref},
+    source: u32,
+    tile_origin: vec3<i32>,
+    lane: u32
+) {
+    for (var iteration = 0u; iteration < GRID_TILE_LOAD_ROUNDS; iteration++) {
+        let index = iteration * GRID_TILE_THREADS + lane;
+
+        if (index < GRID_TILE_HALO_CELLS) {
+            let window_local = tile_origin + grid_tile_halo_local(index);
+
+            var value: vec4<f32>;
+
+            if (grid_tile_window_contains(window_local, window.size)) {
+                value = grid_tile_vec4_fetch_inside(
+                    source,
+                    grid_tile_window_storage(window_local, window.corner_storage, window.period)
+                );
+            } else {
+                value = grid_tile_vec4_fetch_outside(source, window.corner + window_local);
+            }
+
+            (*tile)[index] = value;
+        }
+    }
+
+    workgroupBarrier();
+}
+
+fn grid_tile_vec4_read(tile: ptr<workgroup, array<vec4<f32>, GRID_TILE_HALO_CELLS>>, local: vec3<i32>) -> vec4<f32> {
+    return (*tile)[grid_tile_halo_index(local)];
+}
+
+fn grid_tile_vec4_write(tile: ptr<workgroup, array<vec4<f32>, GRID_TILE_HALO_CELLS>>, local: vec3<i32>, value: vec4<f32>) {
+    (*tile)[grid_tile_halo_index(local)] = value;
+}
+`, [
+    GRID_TILE_WINDOW_STRUCT.declaration_chunk,
+    chunk_grid_tile_window,
+]);

package/src/shade/renderer/shader/chunk/grid/chunk_grid_tile_window.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Interior cells of a tile on each axis: 8 x 8 x 4, one cell per invocation of a 256-invocation
+ * workgroup.
+ * @type {number[]}
+ */
+export const GRID_TILE_SIZE: number[];
+/**
+ * The tile with a one-cell halo on every side: 10 x 10 x 6.
+ * @type {number[]}
+ */
+export const GRID_TILE_HALO_SIZE: number[];
+/**
+ * Cells of the tile with its halo, 600: 2400 bytes of workgroup memory as f32, 9600 as vec4.
+ * @type {number}
+ */
+export const GRID_TILE_HALO_CELLS: number;
+/**
+ * Invocations of a workgroup that loads a tile: one per interior cell.
+ * @type {number}
+ */
+export const GRID_TILE_THREADS: number;
+/**
+ * Cells each invocation loads at most: 600 over 256 invocations.
+ * @type {number}
+ */
+export const GRID_TILE_LOAD_ROUNDS: number;
+/**
+ * The index maths shared by {@link chunk_grid_tile_halo_f32} and {@link chunk_grid_tile_halo_vec4}:
+ * the halo block's layout, and where a window-local cell is stored. All of it is per invocation and
+ * pure; the halo chunks are the workgroup memory and the barrier around it.
+ *
+ * **Tile-local** coordinates are relative to a tile's first interior cell, so the block a tile
+ * loads spans `[-1, 8] x [-1, 8] x [-1, 4]` and its interior `[0, 8) x [0, 8) x [0, 4)`. The block
+ * is stored x fastest, then y, then z.
+ *
+ * Window-local, world and storage cells are as in {@link GRID_TILE_WINDOW_STRUCT}.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_grid_tile_window: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_grid_tile_window.d.ts.map

package/src/shade/renderer/shader/chunk/grid/chunk_grid_tile_window.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_grid_tile_window.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/grid/chunk_grid_tile_window.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,6BAFU,MAAM,EAAE,CAEqC;AAEvD;;;GAGG;AACH,kCAFU,MAAM,EAAE,CAE+D;AAEjF;;;GAGG;AACH,mCAFU,MAAM,CAE6F;AAE7G;;;GAGG;AACH,gCAFU,MAAM,CAE2E;AAE3F;;;GAGG;AACH,oCAFU,MAAM,CAEyE;AAEzF;;;;;;;;;;;;GAYG;AACH,qCAFU,SAAS,CAyChB;0BAvFuB,6BAA6B"}

package/src/shade/renderer/shader/chunk/grid/chunk_grid_tile_window.js

@@ -0,0 +1,88 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+import { chunk_grid3d_to_index } from "./chunk_grid3d_to_index.js";
+import { chunk_index_to_grid3d } from "./chunk_index_to_grid3d.js";
+
+/**
+ * Interior cells of a tile on each axis: 8 x 8 x 4, one cell per invocation of a 256-invocation
+ * workgroup.
+ * @type {number[]}
+ */
+export const GRID_TILE_SIZE = Object.freeze([8, 8, 4]);
+
+/**
+ * The tile with a one-cell halo on every side: 10 x 10 x 6.
+ * @type {number[]}
+ */
+export const GRID_TILE_HALO_SIZE = Object.freeze(GRID_TILE_SIZE.map(n => n + 2));
+
+/**
+ * Cells of the tile with its halo, 600: 2400 bytes of workgroup memory as f32, 9600 as vec4.
+ * @type {number}
+ */
+export const GRID_TILE_HALO_CELLS = GRID_TILE_HALO_SIZE[0] * GRID_TILE_HALO_SIZE[1] * GRID_TILE_HALO_SIZE[2];
+
+/**
+ * Invocations of a workgroup that loads a tile: one per interior cell.
+ * @type {number}
+ */
+export const GRID_TILE_THREADS = GRID_TILE_SIZE[0] * GRID_TILE_SIZE[1] * GRID_TILE_SIZE[2];
+
+/**
+ * Cells each invocation loads at most: 600 over 256 invocations.
+ * @type {number}
+ */
+export const GRID_TILE_LOAD_ROUNDS = Math.ceil(GRID_TILE_HALO_CELLS / GRID_TILE_THREADS);
+
+/**
+ * The index maths shared by {@link chunk_grid_tile_halo_f32} and {@link chunk_grid_tile_halo_vec4}:
+ * the halo block's layout, and where a window-local cell is stored. All of it is per invocation and
+ * pure; the halo chunks are the workgroup memory and the barrier around it.
+ *
+ * **Tile-local** coordinates are relative to a tile's first interior cell, so the block a tile
+ * loads spans `[-1, 8] x [-1, 8] x [-1, 4]` and its interior `[0, 8) x [0, 8) x [0, 4)`. The block
+ * is stored x fastest, then y, then z.
+ *
+ * Window-local, world and storage cells are as in {@link GRID_TILE_WINDOW_STRUCT}.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_grid_tile_window = CodeChunk.from(
+    //language=WGSL
+    `
+const GRID_TILE_SIZE = vec3<i32>(${GRID_TILE_SIZE.join(', ')});
+const GRID_TILE_HALO_CELLS = ${GRID_TILE_HALO_CELLS}u;
+const GRID_TILE_THREADS = ${GRID_TILE_THREADS}u;
+const GRID_TILE_LOAD_ROUNDS = ${GRID_TILE_LOAD_ROUNDS}u;
+
+// The tile-local cell at index of the halo block.
+fn grid_tile_halo_local(index: u32) -> vec3<i32> {
+    let block = index_to_grid3d(index, vec2<u32>(${GRID_TILE_HALO_SIZE[0]}u, ${GRID_TILE_HALO_SIZE[1]}u));
+
+    return vec3<i32>(block) - vec3<i32>(1);
+}
+
+// The index in the halo block of a tile-local cell, which must lie in the block.
+fn grid_tile_halo_index(local: vec3<i32>) -> u32 {
+    return grid3d_to_index(
+        vec3<u32>(local + vec3<i32>(1)),
+        vec2<u32>(${GRID_TILE_HALO_SIZE[0]}u, ${GRID_TILE_HALO_SIZE[1]}u)
+    );
+}
+
+// Whether a window-local cell lies inside a window of size cells on each axis.
+fn grid_tile_window_contains(window_local: vec3<i32>, size: vec3<u32>) -> bool {
+    return all(window_local >= vec3<i32>(0)) && all(window_local < vec3<i32>(size));
+}
+
+// Where a window-local cell inside the window is stored: the corner's storage cell plus the
+// offset, which is below twice the period because the offset is below the size and the size at
+// most the period, so one conditional subtract wraps it.
+fn grid_tile_window_storage(window_local: vec3<i32>, corner_storage: vec3<u32>, period: vec3<u32>) -> vec3<u32> {
+    let unwrapped = corner_storage + vec3<u32>(window_local);
+
+    return select(unwrapped, unwrapped - period, unwrapped >= period);
+}
+`, [
+    chunk_grid3d_to_index,
+    chunk_index_to_grid3d,
+]);

package/src/shade/renderer/shader/chunk/light/lpv/chunk_lpv_mesh_get_vertices.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_lpv_mesh_get_vertices.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/light/lpv/chunk_lpv_mesh_get_vertices.js"],"names":[],"mappings":"AAIA,oDAcE;0BAjBwB,gCAAgC"}
+{"version":3,"file":"chunk_lpv_mesh_get_vertices.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/light/lpv/chunk_lpv_mesh_get_vertices.js"],"names":[],"mappings":"AAKA,oDAcE;0BAlBwB,gCAAgC"}

package/src/shade/renderer/shader/chunk/light/lpv/chunk_lpv_mesh_get_vertices.js

@@ -1,6 +1,7 @@
 import { TETRAHEDRAL_MESH_CELL_STRUCT } from "../../../../global_illumination/lpv/TETRAHEDRAL_MESH_CELL_STRUCT.js";
 import { CodeChunk } from "../../../compiler/CodeChunk.js";
 import { chunk_u32_array_as_vec4 } from "../../geometry/vec4/chunk_f32_array_as_vec4.js";
+import { LPV_MESH_RESOURCE } from "../../../../global_illumination/probe/octahedral/LPV_SHADER_RESOURCE_GROUP.js";
 
 export const chunk_lpv_mesh_get_vertices = CodeChunk.from(
     //language=WGSL
@@ -16,4 +17,6 @@ fn lpv_mesh_get_vertices(tet_index: u32) -> vec4<u32>{
     [
         TETRAHEDRAL_MESH_CELL_STRUCT.declaration_chunk,
     ]
-);
+);
+
+chunk_lpv_mesh_get_vertices.requireResource(LPV_MESH_RESOURCE);

package/src/shade/renderer/shader/chunk/light/lpv/chunk_lpv_mesh_lookup_nearest_cell.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_lpv_mesh_lookup_nearest_cell.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/light/lpv/chunk_lpv_mesh_lookup_nearest_cell.js"],"names":[],"mappings":"AAMA,2DAyDO;0BA/DmB,gCAAgC"}
+{"version":3,"file":"chunk_lpv_mesh_lookup_nearest_cell.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/light/lpv/chunk_lpv_mesh_lookup_nearest_cell.js"],"names":[],"mappings":"AAOA,2DAyDO;0BAhEmB,gCAAgC"}

package/src/shade/renderer/shader/chunk/light/lpv/chunk_lpv_mesh_lookup_nearest_cell.js

@@ -3,6 +3,7 @@ import { BVH_NULL_NODE_DEFINITION } from "../../bvh/BVH_NULL_NODE_DEFINITION.js"
 import { chunk_aabb3_intersects_point } from "../../geometry/aabb3/chunk_aabb3_intersects_point.js";
 import { chunk_lpv_mesh_get_barycentric_coordinates } from "./chunk_lpv_mesh_get_barycentric_coordinates.js";
 import { INVALID_TET_DECLARATION } from "./INVALID_TET_DECLARATION.js";
+import { LPV_LOOKUP_RESOURCE } from "../../../../global_illumination/probe/octahedral/LPV_SHADER_RESOURCE_GROUP.js";
 
 export const chunk_lpv_mesh_lookup_nearest_cell = CodeChunk.from(
     //language=WGSL
@@ -61,4 +62,6 @@ fn lpv_mesh_lookup_nearest_cell(position: vec3<f32>, out_weights:ptr<function, v
         BVH_NULL_NODE_DEFINITION,
         chunk_aabb3_intersects_point,
         chunk_lpv_mesh_get_barycentric_coordinates,
-    ]);
+    ]);
+
+chunk_lpv_mesh_lookup_nearest_cell.requireResource(LPV_LOOKUP_RESOURCE);

package/src/shade/renderer/shader/chunk/light/lpv/chunk_lpv_probe_get_data.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_lpv_probe_get_data.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/light/lpv/chunk_lpv_probe_get_data.js"],"names":[],"mappings":"AAEA,iDAgBG;0BAlBuB,gCAAgC"}
+{"version":3,"file":"chunk_lpv_probe_get_data.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/light/lpv/chunk_lpv_probe_get_data.js"],"names":[],"mappings":"AAGA,iDAgBG;0BAnBuB,gCAAgC"}

package/src/shade/renderer/shader/chunk/light/lpv/chunk_lpv_probe_get_data.js

@@ -1,4 +1,5 @@
 import { CodeChunk } from "../../../compiler/CodeChunk.js";
+import { LPV_PROBES_RESOURCE } from "../../../../global_illumination/probe/octahedral/LPV_SHADER_RESOURCE_GROUP.js";
 
 export const chunk_lpv_probe_get_data = CodeChunk.from(
     //language=WGSL
@@ -16,4 +17,6 @@ fn lpv_probe_get_data(probe_index:u32) -> array< vec3<f32>, 4 >{
         
     return out;
 }
-`);
+`);
+
+chunk_lpv_probe_get_data.requireResource(LPV_PROBES_RESOURCE);

package/src/shade/renderer/shader/chunk/light/lpv/chunk_lpv_probe_get_position.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_lpv_probe_get_position.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/light/lpv/chunk_lpv_probe_get_position.js"],"names":[],"mappings":"AAGA,qDAUO;0BAbmB,gCAAgC"}
+{"version":3,"file":"chunk_lpv_probe_get_position.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/light/lpv/chunk_lpv_probe_get_position.js"],"names":[],"mappings":"AAIA,qDAUO;0BAdmB,gCAAgC"}

package/src/shade/renderer/shader/chunk/light/lpv/chunk_lpv_probe_get_position.js

@@ -1,5 +1,6 @@
 import { CodeChunk } from "../../../compiler/CodeChunk.js";
 import { chunk_f32_array_as_vec3 } from "../../geometry/vec3/chunk_f32_array_as_vec3.js";
+import { LPV_PROBES_RESOURCE } from "../../../../global_illumination/probe/octahedral/LPV_SHADER_RESOURCE_GROUP.js";
 
 export const chunk_lpv_probe_get_position = CodeChunk.from(
     //language=WGSL
@@ -11,4 +12,6 @@ fn lpv_probe_get_position(probe_index: u32) -> vec3<f32>{
 }
 `, [
         chunk_f32_array_as_vec3
-    ]);
+    ]);
+
+chunk_lpv_probe_get_position.requireResource(LPV_PROBES_RESOURCE);

package/src/shade/renderer/shader/chunk/light/lpv/chunk_lpv_sample_radiance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_lpv_sample_radiance.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/light/lpv/chunk_lpv_sample_radiance.js"],"names":[],"mappings":"AAOA,kDAkDO;0BAvDmB,gCAAgC"}
+{"version":3,"file":"chunk_lpv_sample_radiance.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/light/lpv/chunk_lpv_sample_radiance.js"],"names":[],"mappings":"AAQA,kDAkDO;0BAxDmB,gCAAgC"}

package/src/shade/renderer/shader/chunk/light/lpv/chunk_lpv_sample_radiance.js

@@ -4,6 +4,7 @@ import { CodeChunk } from "../../../compiler/CodeChunk.js";
 import { chunk_lpv_mesh_lookup_nearest_cell } from "./chunk_lpv_mesh_lookup_nearest_cell.js";
 import { chunk_lpv_mask_weights_by_visibility } from "./depth/chunk_lpv_mask_weights_by_visibility.js";
 import { INVALID_TET_DECLARATION } from "./INVALID_TET_DECLARATION.js";
+import { LPV_MESH_RESOURCE } from "../../../../global_illumination/probe/octahedral/LPV_SHADER_RESOURCE_GROUP.js";
 
 export const chunk_lpv_sample_radiance = CodeChunk.from(
     //language=WGSL
@@ -55,4 +56,6 @@ fn lpv_sample_radiance(
         chunk_lpv_mesh_lookup_nearest_cell,
         chunk_lpv_mask_weights_by_visibility,
 
-    ]);
+    ]);
+
+chunk_lpv_sample_radiance.requireResource(LPV_MESH_RESOURCE);

package/src/shade/renderer/shader/chunk/light/lpv/depth/chunk_lpv_mask_weights_by_visibility.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_lpv_mask_weights_by_visibility.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/shader/chunk/light/lpv/depth/chunk_lpv_mask_weights_by_visibility.js"],"names":[],"mappings":"AAMA,6DAqGO;AAGP,sEA+EO;0BA1LmB,mCAAmC"}
+{"version":3,"file":"chunk_lpv_mask_weights_by_visibility.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/shader/chunk/light/lpv/depth/chunk_lpv_mask_weights_by_visibility.js"],"names":[],"mappings":"AAOA,6DAqGO;AAKP,sEA+EO;0BA7LmB,mCAAmC"}