@woosh/meep-engine 2.169.0 → 2.169.2

package/src/engine/graphics/sh3/lightmap/lightmap_dilate.d.ts

@@ -8,6 +8,10 @@
  * for the next iteration. Operates in place on a flat, row-major, `channels`-wide
  * pixel buffer.
  *
+ * Delegates to {@link grid_dilate_average} with a single z slice: the 3D
+ * face-neighbour sweep reduces to exactly 4-connected when `size_z` is 1. The
+ * light-probe grid runs the same kernel in 3D.
+ *
  * @param {Float32Array|number[]} data flat row-major pixel data, length width*height*channels
  * @param {Uint8Array} coverage flat row-major coverage mask (1 = has valid lighting), mutated
  * @param {number} width

package/src/engine/graphics/sh3/lightmap/lightmap_dilate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lightmap_dilate.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lightmap/lightmap_dilate.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,sCAPW,YAAY,GAAC,MAAM,EAAE,YACrB,UAAU,SACV,MAAM,UACN,MAAM,YACN,MAAM,cACN,MAAM,QA6DhB"}
+{"version":3,"file":"lightmap_dilate.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lightmap/lightmap_dilate.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,sCAPW,YAAY,GAAC,MAAM,EAAE,YACrB,UAAU,SACV,MAAM,UACN,MAAM,YACN,MAAM,cACN,MAAM,QAIhB"}

package/src/engine/graphics/sh3/lightmap/lightmap_dilate.js

@@ -1,3 +1,5 @@
+import { grid_dilate_average } from "../grid_dilate_average.js";
+
 /**
  * Grow ("dilate") covered texels outward into their uncovered neighbours, so that
  * bilinear sampling across a chart boundary blends with valid lighting instead of
@@ -8,6 +10,10 @@
  * for the next iteration. Operates in place on a flat, row-major, `channels`-wide
  * pixel buffer.
  *
+ * Delegates to {@link grid_dilate_average} with a single z slice: the 3D
+ * face-neighbour sweep reduces to exactly 4-connected when `size_z` is 1. The
+ * light-probe grid runs the same kernel in 3D.
+ *
  * @param {Float32Array|number[]} data flat row-major pixel data, length width*height*channels
  * @param {Uint8Array} coverage flat row-major coverage mask (1 = has valid lighting), mutated
  * @param {number} width
@@ -16,74 +22,5 @@
  * @param {number} iterations how many texels of border to grow (≈ the atlas padding)
  */
 export function lightmap_dilate(data, coverage, width, height, channels, iterations) {
-    const acc = new Float64Array(channels);
-
-    for (let iter = 0; iter < iterations; iter++) {
-        // texels that become covered this round; deferred so a single pass does not
-        // chain-fill along a row from a texel filled earlier in the same iteration
-        const newly = [];
-
-        for (let y = 0; y < height; y++) {
-            for (let x = 0; x < width; x++) {
-                const index = y * width + x;
-
-                if (coverage[index] !== 0) {
-                    continue;
-                }
-
-                acc.fill(0);
-                let n = 0;
-
-                if (x > 0 && coverage[index - 1] !== 0) {
-                    accumulate(acc, data, (index - 1) * channels, channels);
-                    n++;
-                }
-                if (x < width - 1 && coverage[index + 1] !== 0) {
-                    accumulate(acc, data, (index + 1) * channels, channels);
-                    n++;
-                }
-                if (y > 0 && coverage[index - width] !== 0) {
-                    accumulate(acc, data, (index - width) * channels, channels);
-                    n++;
-                }
-                if (y < height - 1 && coverage[index + width] !== 0) {
-                    accumulate(acc, data, (index + width) * channels, channels);
-                    n++;
-                }
-
-                if (n === 0) {
-                    continue;
-                }
-
-                const base = index * channels;
-                const inv = 1 / n;
-                for (let c = 0; c < channels; c++) {
-                    data[base + c] = acc[c] * inv;
-                }
-
-                newly.push(index);
-            }
-        }
-
-        if (newly.length === 0) {
-            // fully grown, nothing left to reach
-            break;
-        }
-
-        for (let i = 0; i < newly.length; i++) {
-            coverage[newly[i]] = 1;
-        }
-    }
-}
-
-/**
- * @param {Float64Array} acc
- * @param {Float32Array|number[]} data
- * @param {number} offset
- * @param {number} channels
- */
-function accumulate(acc, data, offset, channels) {
-    for (let c = 0; c < channels; c++) {
-        acc[c] += data[offset + c];
-    }
+    grid_dilate_average(data, coverage, width, height, 1, channels, iterations);
 }

package/src/engine/graphics/sh3/lightmap/lightmap_rasterize_triangle.d.ts

@@ -23,8 +23,8 @@
  * @param {number} cy vertex C y, in pixels
  * @param {number} width raster width (texel centers tested in [0, width))
  * @param {number} height raster height (texel centers tested in [0, height))
- * @param {function(px:number, py:number, wA:number, wB:number, wC:number):void} callback
+ * @param {(px: number, py: number, wA: number, wB: number, wC: number) => void} callback
  * @param {boolean} [conservative] include edge-overlapping texels with a clamped sample (default false)
  */
-export function lightmap_rasterize_triangle(ax: number, ay: number, bx: number, by: number, cx: number, cy: number, width: number, height: number, callback: any, conservative?: boolean): void;
+export function lightmap_rasterize_triangle(ax: number, ay: number, bx: number, by: number, cx: number, cy: number, width: number, height: number, callback: (px: number, py: number, wA: number, wB: number, wC: number) => void, conservative?: boolean): void;
 //# sourceMappingURL=lightmap_rasterize_triangle.d.ts.map

package/src/engine/graphics/sh3/lightmap/lightmap_rasterize_triangle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lightmap_rasterize_triangle.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lightmap/lightmap_rasterize_triangle.js"],"names":[],"mappings":"AAsDA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,gDAXW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,SACN,MAAM,UACN,MAAM,gCAEN,OAAO,QAgEjB"}
+{"version":3,"file":"lightmap_rasterize_triangle.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lightmap/lightmap_rasterize_triangle.js"],"names":[],"mappings":"AAsDA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,gDAXW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,SACN,MAAM,UACN,MAAM,iBACD,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,KAAK,IAAI,iBACpE,OAAO,QAgEjB"}

package/src/engine/graphics/sh3/lightmap/lightmap_rasterize_triangle.js

@@ -1,145 +1,145 @@
-/** Half the diagonal of a unit texel — the conservative overlap reach from a center. */
-const HALF_TEXEL_DIAGONAL = Math.SQRT2 * 0.5;
-
-/**
- * Closest point to (px,py) on segment (ax,ay)->(bx,by), written to out[0..1].
- *
- * @param {Float32Array|number[]} out
- * @param {number} px
- * @param {number} py
- * @param {number} ax
- * @param {number} ay
- * @param {number} bx
- * @param {number} by
- */
-function closest_on_segment(out, px, py, ax, ay, bx, by) {
-    const ex = bx - ax;
-    const ey = by - ay;
-    const len2 = ex * ex + ey * ey;
-    let t = len2 > 0 ? ((px - ax) * ex + (py - ay) * ey) / len2 : 0;
-    if (t < 0) t = 0; else if (t > 1) t = 1;
-    out[0] = ax + t * ex;
-    out[1] = ay + t * ey;
-}
-
-const _q = new Float32Array(2);
-const _e = new Float32Array(2);
-
-/**
- * Closest point to (px,py) on the (filled) triangle, written to out[0..1].
- * Assumes the point is outside the triangle (callers test inside first).
- *
- * @param {Float32Array|number[]} out
- */
-function closest_on_triangle(out, px, py, ax, ay, bx, by, cx, cy) {
-    let best_d2 = Infinity;
-
-    closest_on_segment(_e, px, py, ax, ay, bx, by);
-    let dx = px - _e[0], dy = py - _e[1];
-    let d2 = dx * dx + dy * dy;
-    if (d2 < best_d2) { best_d2 = d2; out[0] = _e[0]; out[1] = _e[1]; }
-
-    closest_on_segment(_e, px, py, bx, by, cx, cy);
-    dx = px - _e[0]; dy = py - _e[1];
-    d2 = dx * dx + dy * dy;
-    if (d2 < best_d2) { best_d2 = d2; out[0] = _e[0]; out[1] = _e[1]; }
-
-    closest_on_segment(_e, px, py, cx, cy, ax, ay);
-    dx = px - _e[0]; dy = py - _e[1];
-    d2 = dx * dx + dy * dy;
-    if (d2 < best_d2) { best_d2 = d2; out[0] = _e[0]; out[1] = _e[1]; }
-
-    return Math.sqrt(best_d2);
-}
-
-/**
- * Rasterize a 2D triangle in integer pixel space, invoking `callback` once per
- * covered texel with the barycentric weights of the three vertices (A, B, C) at
- * the sampled point. The weights are an exact partition of unity (`wA+wB+wC===1`,
- * all `>=0`), so a caller can interpolate any per-vertex attribute directly.
- *
- * Default (center) mode: a texel is covered iff its CENTER lies inside the
- * triangle, sampled at that center.
- *
- * Conservative mode (`conservative === true`): a texel is also covered if its
- * cell overlaps the triangle even though its center is outside (thin features,
- * chart borders). For those, the sample is **clamped to the closest point on the
- * triangle** so the interpolated position/normal stays on the surface — avoiding
- * the dropped-edge-texel black gutters of center-only coverage.
- *
- * Degenerate (zero-area) triangles produce no callbacks.
- *
- * @param {number} ax vertex A x, in pixels
- * @param {number} ay vertex A y, in pixels
- * @param {number} bx vertex B x, in pixels
- * @param {number} by vertex B y, in pixels
- * @param {number} cx vertex C x, in pixels
- * @param {number} cy vertex C y, in pixels
- * @param {number} width raster width (texel centers tested in [0, width))
- * @param {number} height raster height (texel centers tested in [0, height))
- * @param {function(px:number, py:number, wA:number, wB:number, wC:number):void} callback
- * @param {boolean} [conservative] include edge-overlapping texels with a clamped sample (default false)
- */
-export function lightmap_rasterize_triangle(ax, ay, bx, by, cx, cy, width, height, callback, conservative = false) {
-    // conservative mode reaches one extra texel of overlap, so widen the scan box
-    const margin = conservative ? 1 : 0;
-
-    const min_x = Math.max(0, Math.floor(Math.min(ax, bx, cx)) - margin);
-    const max_x = Math.min(width - 1, Math.floor(Math.max(ax, bx, cx)) + margin);
-    const min_y = Math.max(0, Math.floor(Math.min(ay, by, cy)) - margin);
-    const max_y = Math.min(height - 1, Math.floor(Math.max(ay, by, cy)) + margin);
-
-    const d = (by - cy) * (ax - cx) + (cx - bx) * (ay - cy);
-
-    if (d === 0) {
-        // degenerate triangle, no area to cover
-        return;
-    }
-
-    const inv_d = 1 / d;
-
-    for (let py = min_y; py <= max_y; py++) {
-        const sy = py + 0.5;
-
-        for (let px = min_x; px <= max_x; px++) {
-            const sx = px + 0.5;
-
-            const wA = ((by - cy) * (sx - cx) + (cx - bx) * (sy - cy)) * inv_d;
-            const wB = ((cy - ay) * (sx - cx) + (ax - cx) * (sy - cy)) * inv_d;
-            const wC = 1 - wA - wB;
-
-            if (wA >= 0 && wB >= 0 && wC >= 0) {
-                callback(px, py, wA, wB, wC);
-                continue;
-            }
-
-            if (!conservative) {
-                continue;
-            }
-
-            // center is outside: keep the texel only if its cell overlaps the
-            // triangle, sampling the clamped (on-triangle) closest point
-            const dist = closest_on_triangle(_q, sx, sy, ax, ay, bx, by, cx, cy);
-            if (dist > HALF_TEXEL_DIAGONAL) {
-                continue;
-            }
-
-            const qx = _q[0];
-            const qy = _q[1];
-            let cwA = ((by - cy) * (qx - cx) + (cx - bx) * (qy - cy)) * inv_d;
-            let cwB = ((cy - ay) * (qx - cx) + (ax - cx) * (qy - cy)) * inv_d;
-            // clamp tiny negative fp drift so the weights stay a valid convex combo
-            if (cwA < 0) cwA = 0;
-            if (cwB < 0) cwB = 0;
-            let cwC = 1 - cwA - cwB;
-            if (cwC < 0) {
-                cwC = 0;
-                const s = cwA + cwB;
-                cwA /= s;
-                cwB /= s;
-            }
-
-            callback(px, py, cwA, cwB, cwC);
-        }
-    }
-}
+/** Half the diagonal of a unit texel — the conservative overlap reach from a center. */
+const HALF_TEXEL_DIAGONAL = Math.SQRT2 * 0.5;
+
+/**
+ * Closest point to (px,py) on segment (ax,ay)->(bx,by), written to out[0..1].
+ *
+ * @param {Float32Array|number[]} out
+ * @param {number} px
+ * @param {number} py
+ * @param {number} ax
+ * @param {number} ay
+ * @param {number} bx
+ * @param {number} by
+ */
+function closest_on_segment(out, px, py, ax, ay, bx, by) {
+    const ex = bx - ax;
+    const ey = by - ay;
+    const len2 = ex * ex + ey * ey;
+    let t = len2 > 0 ? ((px - ax) * ex + (py - ay) * ey) / len2 : 0;
+    if (t < 0) t = 0; else if (t > 1) t = 1;
+    out[0] = ax + t * ex;
+    out[1] = ay + t * ey;
+}
+
+const _q = new Float32Array(2);
+const _e = new Float32Array(2);
+
+/**
+ * Closest point to (px,py) on the (filled) triangle, written to out[0..1].
+ * Assumes the point is outside the triangle (callers test inside first).
+ *
+ * @param {Float32Array|number[]} out
+ */
+function closest_on_triangle(out, px, py, ax, ay, bx, by, cx, cy) {
+    let best_d2 = Infinity;
+
+    closest_on_segment(_e, px, py, ax, ay, bx, by);
+    let dx = px - _e[0], dy = py - _e[1];
+    let d2 = dx * dx + dy * dy;
+    if (d2 < best_d2) { best_d2 = d2; out[0] = _e[0]; out[1] = _e[1]; }
+
+    closest_on_segment(_e, px, py, bx, by, cx, cy);
+    dx = px - _e[0]; dy = py - _e[1];
+    d2 = dx * dx + dy * dy;
+    if (d2 < best_d2) { best_d2 = d2; out[0] = _e[0]; out[1] = _e[1]; }
+
+    closest_on_segment(_e, px, py, cx, cy, ax, ay);
+    dx = px - _e[0]; dy = py - _e[1];
+    d2 = dx * dx + dy * dy;
+    if (d2 < best_d2) { best_d2 = d2; out[0] = _e[0]; out[1] = _e[1]; }
+
+    return Math.sqrt(best_d2);
+}
+
+/**
+ * Rasterize a 2D triangle in integer pixel space, invoking `callback` once per
+ * covered texel with the barycentric weights of the three vertices (A, B, C) at
+ * the sampled point. The weights are an exact partition of unity (`wA+wB+wC===1`,
+ * all `>=0`), so a caller can interpolate any per-vertex attribute directly.
+ *
+ * Default (center) mode: a texel is covered iff its CENTER lies inside the
+ * triangle, sampled at that center.
+ *
+ * Conservative mode (`conservative === true`): a texel is also covered if its
+ * cell overlaps the triangle even though its center is outside (thin features,
+ * chart borders). For those, the sample is **clamped to the closest point on the
+ * triangle** so the interpolated position/normal stays on the surface — avoiding
+ * the dropped-edge-texel black gutters of center-only coverage.
+ *
+ * Degenerate (zero-area) triangles produce no callbacks.
+ *
+ * @param {number} ax vertex A x, in pixels
+ * @param {number} ay vertex A y, in pixels
+ * @param {number} bx vertex B x, in pixels
+ * @param {number} by vertex B y, in pixels
+ * @param {number} cx vertex C x, in pixels
+ * @param {number} cy vertex C y, in pixels
+ * @param {number} width raster width (texel centers tested in [0, width))
+ * @param {number} height raster height (texel centers tested in [0, height))
+ * @param {(px: number, py: number, wA: number, wB: number, wC: number) => void} callback
+ * @param {boolean} [conservative] include edge-overlapping texels with a clamped sample (default false)
+ */
+export function lightmap_rasterize_triangle(ax, ay, bx, by, cx, cy, width, height, callback, conservative = false) {
+    // conservative mode reaches one extra texel of overlap, so widen the scan box
+    const margin = conservative ? 1 : 0;
+
+    const min_x = Math.max(0, Math.floor(Math.min(ax, bx, cx)) - margin);
+    const max_x = Math.min(width - 1, Math.floor(Math.max(ax, bx, cx)) + margin);
+    const min_y = Math.max(0, Math.floor(Math.min(ay, by, cy)) - margin);
+    const max_y = Math.min(height - 1, Math.floor(Math.max(ay, by, cy)) + margin);
+
+    const d = (by - cy) * (ax - cx) + (cx - bx) * (ay - cy);
+
+    if (d === 0) {
+        // degenerate triangle, no area to cover
+        return;
+    }
+
+    const inv_d = 1 / d;
+
+    for (let py = min_y; py <= max_y; py++) {
+        const sy = py + 0.5;
+
+        for (let px = min_x; px <= max_x; px++) {
+            const sx = px + 0.5;
+
+            const wA = ((by - cy) * (sx - cx) + (cx - bx) * (sy - cy)) * inv_d;
+            const wB = ((cy - ay) * (sx - cx) + (ax - cx) * (sy - cy)) * inv_d;
+            const wC = 1 - wA - wB;
+
+            if (wA >= 0 && wB >= 0 && wC >= 0) {
+                callback(px, py, wA, wB, wC);
+                continue;
+            }
+
+            if (!conservative) {
+                continue;
+            }
+
+            // center is outside: keep the texel only if its cell overlaps the
+            // triangle, sampling the clamped (on-triangle) closest point
+            const dist = closest_on_triangle(_q, sx, sy, ax, ay, bx, by, cx, cy);
+            if (dist > HALF_TEXEL_DIAGONAL) {
+                continue;
+            }
+
+            const qx = _q[0];
+            const qy = _q[1];
+            let cwA = ((by - cy) * (qx - cx) + (cx - bx) * (qy - cy)) * inv_d;
+            let cwB = ((cy - ay) * (qx - cx) + (ax - cx) * (qy - cy)) * inv_d;
+            // clamp tiny negative fp drift so the weights stay a valid convex combo
+            if (cwA < 0) cwA = 0;
+            if (cwB < 0) cwB = 0;
+            let cwC = 1 - cwA - cwB;
+            if (cwC < 0) {
+                cwC = 0;
+                const s = cwA + cwB;
+                cwA /= s;
+                cwB /= s;
+            }
+
+            callback(px, py, cwA, cwB, cwC);
+        }
+    }
+}

package/src/engine/graphics/sh3/lpg/light_probe_grid_dilate.d.ts

@@ -7,6 +7,12 @@
  * only probes that were valid before the pass started, so the result is independent of traversal
  * order. Probes with no valid probe anywhere in their connected region are left untouched.
  *
+ * Delegates to {@link grid_dilate_average}, the kernel the 2D lightmap gutter fill also uses.
+ * The iteration cap is the grid's L1 diameter, which is the exact worst case: every pass advances
+ * the filled front by one cell along each axis, so a reachable probe is always filled within
+ * `resolution_x + resolution_y + resolution_z` passes. It is a bound, not an early stop — the sweep
+ * still ends as soon as a pass fills nothing.
+ *
  * @param {Float32Array} harmonics probe data, {@link PROBE_VALUE_COUNT} values per probe; filled probes are written in place
  * @param {Uint8Array} validity one flag per probe, non-zero = valid; filled probes are marked valid in place
  * @param {number} resolution_x

package/src/engine/graphics/sh3/lpg/light_probe_grid_dilate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"light_probe_grid_dilate.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpg/light_probe_grid_dilate.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;GAeG;AACH,mDAPW,YAAY,YACZ,UAAU,gBACV,MAAM,gBACN,MAAM,gBACN,MAAM,GACJ,MAAM,CAsGlB"}
+{"version":3,"file":"light_probe_grid_dilate.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpg/light_probe_grid_dilate.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,mDAPW,YAAY,YACZ,UAAU,gBACV,MAAM,gBACN,MAAM,gBACN,MAAM,GACJ,MAAM,CAclB"}

package/src/engine/graphics/sh3/lpg/light_probe_grid_dilate.js

@@ -1,4 +1,4 @@
-import { assert } from "../../../../core/assert.js";
+import { grid_dilate_average } from "../grid_dilate_average.js";
 
 /**
  * Values per probe in {@link LightProbeGrid#harmonics}
@@ -6,10 +6,6 @@ import { assert } from "../../../../core/assert.js";
  */
 const PROBE_VALUE_COUNT = 12;
 
-const __accumulator = new Float64Array(PROBE_VALUE_COUNT);
-
-let __source_validity = new Uint8Array(0);
-
 /**
  * Fill invalid probes with the average of their valid 6-connected neighbors, expanding in waves until
  * every reachable probe is filled.
@@ -19,6 +15,12 @@ let __source_validity = new Uint8Array(0);
  * only probes that were valid before the pass started, so the result is independent of traversal
  * order. Probes with no valid probe anywhere in their connected region are left untouched.
  *
+ * Delegates to {@link grid_dilate_average}, the kernel the 2D lightmap gutter fill also uses.
+ * The iteration cap is the grid's L1 diameter, which is the exact worst case: every pass advances
+ * the filled front by one cell along each axis, so a reachable probe is always filled within
+ * `resolution_x + resolution_y + resolution_z` passes. It is a bound, not an early stop — the sweep
+ * still ends as soon as a pass fills nothing.
+ *
  * @param {Float32Array} harmonics probe data, {@link PROBE_VALUE_COUNT} values per probe; filled probes are written in place
  * @param {Uint8Array} validity one flag per probe, non-zero = valid; filled probes are marked valid in place
  * @param {number} resolution_x
@@ -31,112 +33,11 @@ export function light_probe_grid_dilate(
     validity,
     resolution_x, resolution_y, resolution_z
 ) {
-    assert.isNonNegativeInteger(resolution_x, 'resolution_x');
-    assert.isNonNegativeInteger(resolution_y, 'resolution_y');
-    assert.isNonNegativeInteger(resolution_z, 'resolution_z');
-
-    const probe_count = resolution_x * resolution_y * resolution_z;
-
-    assert.greaterThanOrEqual(validity.length, probe_count, 'validity.length');
-    assert.greaterThanOrEqual(harmonics.length, probe_count * PROBE_VALUE_COUNT, 'harmonics.length');
-
-    if (__source_validity.length < probe_count) {
-        __source_validity = new Uint8Array(probe_count);
-    }
-
-    let invalid_count = 0;
-
-    for (let i = 0; i < probe_count; i++) {
-        if (validity[i] === 0) {
-            invalid_count++;
-        }
-    }
-
-    const slice_size = resolution_x * resolution_y;
-
-    let filled_this_pass = 1;
-
-    while (invalid_count > 0 && filled_this_pass > 0) {
-        filled_this_pass = 0;
-
-        // snapshot so each pass only reads probes that were valid before it started
-        __source_validity.set(validity.subarray(0, probe_count));
-
-        for (let z = 0; z < resolution_z; z++) {
-            for (let y = 0; y < resolution_y; y++) {
-                for (let x = 0; x < resolution_x; x++) {
-
-                    const index = x + resolution_x * y + slice_size * z;
-
-                    if (__source_validity[index] !== 0) {
-                        continue;
-                    }
-
-                    __accumulator.fill(0);
-                    let neighbor_count = 0;
-
-                    if (x > 0 && __source_validity[index - 1] !== 0) {
-                        accumulate_probe(harmonics, index - 1);
-                        neighbor_count++;
-                    }
-
-                    if (x < resolution_x - 1 && __source_validity[index + 1] !== 0) {
-                        accumulate_probe(harmonics, index + 1);
-                        neighbor_count++;
-                    }
-
-                    if (y > 0 && __source_validity[index - resolution_x] !== 0) {
-                        accumulate_probe(harmonics, index - resolution_x);
-                        neighbor_count++;
-                    }
-
-                    if (y < resolution_y - 1 && __source_validity[index + resolution_x] !== 0) {
-                        accumulate_probe(harmonics, index + resolution_x);
-                        neighbor_count++;
-                    }
-
-                    if (z > 0 && __source_validity[index - slice_size] !== 0) {
-                        accumulate_probe(harmonics, index - slice_size);
-                        neighbor_count++;
-                    }
-
-                    if (z < resolution_z - 1 && __source_validity[index + slice_size] !== 0) {
-                        accumulate_probe(harmonics, index + slice_size);
-                        neighbor_count++;
-                    }
-
-                    if (neighbor_count === 0) {
-                        continue;
-                    }
-
-                    const probe_address = index * PROBE_VALUE_COUNT;
-                    const inverse_count = 1 / neighbor_count;
-
-                    for (let i = 0; i < PROBE_VALUE_COUNT; i++) {
-                        harmonics[probe_address + i] = __accumulator[i] * inverse_count;
-                    }
-
-                    validity[index] = 1;
-                    filled_this_pass++;
-                }
-            }
-        }
-
-        invalid_count -= filled_this_pass;
-    }
-
-    return invalid_count;
-}
-
-/**
- *
- * @param {Float32Array} harmonics
- * @param {number} probe_index
- */
-function accumulate_probe(harmonics, probe_index) {
-    const address = probe_index * PROBE_VALUE_COUNT;
-
-    for (let i = 0; i < PROBE_VALUE_COUNT; i++) {
-        __accumulator[i] += harmonics[address + i];
-    }
+    return grid_dilate_average(
+        harmonics,
+        validity,
+        resolution_x, resolution_y, resolution_z,
+        PROBE_VALUE_COUNT,
+        resolution_x + resolution_y + resolution_z
+    );
 }

package/src/engine/graphics/sh3/lpg/material/chunk_lpg_get_irradiance_at.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_lpg_get_irradiance_at.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/sh3/lpg/material/chunk_lpg_get_irradiance_at.js"],"names":[],"mappings":"AAIA,wjBAmBC"}
+{"version":3,"file":"chunk_lpg_get_irradiance_at.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/sh3/lpg/material/chunk_lpg_get_irradiance_at.js"],"names":[],"mappings":"AAWA,wjBAmBC"}

package/src/engine/graphics/sh3/lpg/material/chunk_lpg_get_irradiance_at.js

@@ -1,6 +1,13 @@
 
 // source: https://graphics.stanford.edu/papers/envmap/envmap.pdf
 // first two bands of chunk_lpv_get_irradiance_at, constants include the cosine-lobe convolution
+//
+// It cannot literally reuse that chunk: GLSL array parameters are sized, so a
+// `vec3[9]` evaluator cannot be handed the `vec3[4]` the LPG stores. The four
+// shared lines are therefore restated here on purpose. See the sign-convention
+// note in gi/material/chunk_lpv_get_irradiance_at.js — this file follows the
+// same ADDING convention as that one, which is the opposite of
+// core/geom/3d/sphere/harmonics/sh3_sample_irradiance_by_direction.js.
 //language=GLSL
 export const chunk_lpg_get_irradiance_at = `
 #ifndef LPG_CHUNK_GET_IRRADIANCE_AT

package/src/engine/graphics/sh3/lpg/material/space_fragment/build_fragment_shader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build_fragment_shader.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/sh3/lpg/material/space_fragment/build_fragment_shader.js"],"names":[],"mappings":"AA0BA;;;GAGG;AACH,8CAFW,MAAM,UAahB"}
+{"version":3,"file":"build_fragment_shader.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/sh3/lpg/material/space_fragment/build_fragment_shader.js"],"names":[],"mappings":"AA0BA;;;GAGG;AACH,8CAFW,MAAM,UAUhB"}

package/src/engine/graphics/sh3/lpg/material/space_fragment/build_fragment_shader.js

@@ -1,4 +1,4 @@
-import { insert_after } from "../../../../../../core/primitives/strings/insert_after.js";
+import { build_injected_shader, GLSL_ANCHOR_LIGHTS_FRAGMENT_BEGIN } from "../../../build_injected_shader.js";
 import PREAMBLE_COMMON from "../common.js";
 
 //language=GLSL
@@ -30,13 +30,10 @@ const ACCUMULATION = `
  */
 export function build_fragment_shader(source) {
 
-    let result = PREAMBLE + PREAMBLE_COMMON + source;
-
-    result = insert_after(
-        result,
-        '#include <lights_fragment_begin>',
+    return build_injected_shader(
+        source,
+        PREAMBLE + PREAMBLE_COMMON,
+        GLSL_ANCHOR_LIGHTS_FRAGMENT_BEGIN,
         ACCUMULATION
     );
-
-    return result;
 }

package/src/engine/graphics/sh3/lpg/material/space_fragment/build_vertex_shader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build_vertex_shader.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/sh3/lpg/material/space_fragment/build_vertex_shader.js"],"names":[],"mappings":"AAiCA;;;GAGG;AACH,4CAFW,MAAM,UAahB"}
+{"version":3,"file":"build_vertex_shader.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/sh3/lpg/material/space_fragment/build_vertex_shader.js"],"names":[],"mappings":"AAiCA;;;GAGG;AACH,4CAFW,MAAM,UAUhB"}