@woosh/meep-engine 2.169.1 → 2.169.2

package/src/engine/graphics/sh3/gi/material/space_vertex/build_vertex_shader.js

@@ -1,4 +1,4 @@
-import { insert_after } from "../../../../../../core/primitives/strings/insert_after.js";
+import { build_injected_shader, GLSL_ANCHOR_FOG_VERTEX } from "../../../build_injected_shader.js";
 import PREAMBLE_COMMON from "../common.js";
 
 import PREAMBLE from "./preable.vert.js";
@@ -49,15 +49,10 @@ const SHADER_CHUNK_ACCUMULATION = `
  * @param {string} source
  */
 export function build_vertex_shader(source) {
-    let result = PREAMBLE + PREAMBLE_COMMON + source;
-
-    result = insert_after(
-        result,
-        '#include <fog_vertex>',
-        SHADER_CHUNK_ACCUMULATION
+    return build_injected_shader(
+        source,
+        PREAMBLE + PREAMBLE_COMMON,
+        GLSL_ANCHOR_FOG_VERTEX,
+        SHADER_CHUNK_ACCUMULATION
     );
-
-    // console.log(result)
-
-    return result;
-}
+}

package/src/engine/graphics/sh3/grid_dilate_average.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Grow ("dilate") covered cells outward into their uncovered face-neighbours,
+ * filling each with the average of the covered neighbours it touches.
+ *
+ * WHY THIS EXISTS
+ *
+ * The 2D lightmap gutter fill and the 3D light-probe-grid hole fill are the
+ * same algorithm written twice: skip covered cells, accumulate valid
+ * face-neighbours, divide by the count, mark newly covered, repeat. Even the
+ * per-axis guard shape (`x > 0 && coverage[index - 1] !== 0`) matched. They
+ * differed only in dimensionality and in whether the channel count was a
+ * parameter or a constant, so a single 3D implementation covers both — a 2D
+ * caller passes `size_z = 1`, which makes both z guards statically false and
+ * reduces the traversal to exactly 4-connected.
+ *
+ * ORDER INDEPENDENCE
+ *
+ * Each pass reads a snapshot of the coverage mask taken before the pass began,
+ * so a cell filled earlier in a pass cannot seed a cell later in the same pass.
+ * Without that, a `[valid, hole, hole, valid]` row would chain-fill left to
+ * right and the result would depend on traversal order. Cell data itself needs
+ * no snapshot: only uncovered cells are written, and only covered cells are
+ * read.
+ *
+ * This is a bake-time operation — it runs once per lightmap / probe-grid build,
+ * never per frame.
+ *
+ * @param {Float32Array|Float64Array|number[]} data flat row-major cell data, `channels` values per cell; filled cells are written in place
+ * @param {Uint8Array} coverage one flag per cell, non-zero = has valid data; filled cells are marked covered in place
+ * @param {number} size_x
+ * @param {number} size_y
+ * @param {number} size_z pass 1 for a 2D grid
+ * @param {number} channels values per cell
+ * @param {number} iterations maximum number of growth rings; the sweep also stops as soon as a pass fills nothing
+ * @returns {number} number of cells that were still uncovered when the sweep stopped
+ */
+export function grid_dilate_average(data: Float32Array | Float64Array | number[], coverage: Uint8Array, size_x: number, size_y: number, size_z: number, channels: number, iterations: number): number;
+//# sourceMappingURL=grid_dilate_average.d.ts.map

package/src/engine/graphics/sh3/grid_dilate_average.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grid_dilate_average.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/sh3/grid_dilate_average.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,0CATW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,YAClC,UAAU,UACV,MAAM,UACN,MAAM,UACN,MAAM,YACN,MAAM,cACN,MAAM,GACJ,MAAM,CAoHlB"}

package/src/engine/graphics/sh3/grid_dilate_average.js

@@ -0,0 +1,175 @@
+import { assert } from "../../../core/assert.js";
+
+/**
+ * @type {Float64Array}
+ */
+let scratch_accumulator = new Float64Array(0);
+
+/**
+ * @type {Uint8Array}
+ */
+let scratch_coverage_snapshot = new Uint8Array(0);
+
+/**
+ * Grow ("dilate") covered cells outward into their uncovered face-neighbours,
+ * filling each with the average of the covered neighbours it touches.
+ *
+ * WHY THIS EXISTS
+ *
+ * The 2D lightmap gutter fill and the 3D light-probe-grid hole fill are the
+ * same algorithm written twice: skip covered cells, accumulate valid
+ * face-neighbours, divide by the count, mark newly covered, repeat. Even the
+ * per-axis guard shape (`x > 0 && coverage[index - 1] !== 0`) matched. They
+ * differed only in dimensionality and in whether the channel count was a
+ * parameter or a constant, so a single 3D implementation covers both — a 2D
+ * caller passes `size_z = 1`, which makes both z guards statically false and
+ * reduces the traversal to exactly 4-connected.
+ *
+ * ORDER INDEPENDENCE
+ *
+ * Each pass reads a snapshot of the coverage mask taken before the pass began,
+ * so a cell filled earlier in a pass cannot seed a cell later in the same pass.
+ * Without that, a `[valid, hole, hole, valid]` row would chain-fill left to
+ * right and the result would depend on traversal order. Cell data itself needs
+ * no snapshot: only uncovered cells are written, and only covered cells are
+ * read.
+ *
+ * This is a bake-time operation — it runs once per lightmap / probe-grid build,
+ * never per frame.
+ *
+ * @param {Float32Array|Float64Array|number[]} data flat row-major cell data, `channels` values per cell; filled cells are written in place
+ * @param {Uint8Array} coverage one flag per cell, non-zero = has valid data; filled cells are marked covered in place
+ * @param {number} size_x
+ * @param {number} size_y
+ * @param {number} size_z pass 1 for a 2D grid
+ * @param {number} channels values per cell
+ * @param {number} iterations maximum number of growth rings; the sweep also stops as soon as a pass fills nothing
+ * @returns {number} number of cells that were still uncovered when the sweep stopped
+ */
+export function grid_dilate_average(
+    data,
+    coverage,
+    size_x, size_y, size_z,
+    channels,
+    iterations
+) {
+    assert.isNonNegativeInteger(size_x, 'size_x');
+    assert.isNonNegativeInteger(size_y, 'size_y');
+    assert.isNonNegativeInteger(size_z, 'size_z');
+    assert.isNonNegativeInteger(channels, 'channels');
+    assert.isNonNegativeInteger(iterations, 'iterations');
+
+    const cell_count = size_x * size_y * size_z;
+
+    assert.greaterThanOrEqual(coverage.length, cell_count, 'coverage.length');
+    assert.greaterThanOrEqual(data.length, cell_count * channels, 'data.length');
+
+    if (scratch_accumulator.length < channels) {
+        scratch_accumulator = new Float64Array(channels);
+    }
+
+    if (scratch_coverage_snapshot.length < cell_count) {
+        scratch_coverage_snapshot = new Uint8Array(cell_count);
+    }
+
+    const accumulator = scratch_accumulator;
+    const source_coverage = scratch_coverage_snapshot;
+
+    let uncovered_count = 0;
+
+    for (let i = 0; i < cell_count; i++) {
+        if (coverage[i] === 0) {
+            uncovered_count++;
+        }
+    }
+
+    const slice_size = size_x * size_y;
+
+    for (let iteration = 0; iteration < iterations && uncovered_count > 0; iteration++) {
+
+        source_coverage.set(coverage.subarray(0, cell_count));
+
+        let filled_this_pass = 0;
+
+        for (let z = 0; z < size_z; z++) {
+            for (let y = 0; y < size_y; y++) {
+                for (let x = 0; x < size_x; x++) {
+
+                    const index = x + size_x * y + slice_size * z;
+
+                    if (source_coverage[index] !== 0) {
+                        continue;
+                    }
+
+                    accumulator.fill(0, 0, channels);
+                    let neighbour_count = 0;
+
+                    if (x > 0 && source_coverage[index - 1] !== 0) {
+                        accumulate_cell(accumulator, data, (index - 1) * channels, channels);
+                        neighbour_count++;
+                    }
+
+                    if (x < size_x - 1 && source_coverage[index + 1] !== 0) {
+                        accumulate_cell(accumulator, data, (index + 1) * channels, channels);
+                        neighbour_count++;
+                    }
+
+                    if (y > 0 && source_coverage[index - size_x] !== 0) {
+                        accumulate_cell(accumulator, data, (index - size_x) * channels, channels);
+                        neighbour_count++;
+                    }
+
+                    if (y < size_y - 1 && source_coverage[index + size_x] !== 0) {
+                        accumulate_cell(accumulator, data, (index + size_x) * channels, channels);
+                        neighbour_count++;
+                    }
+
+                    if (z > 0 && source_coverage[index - slice_size] !== 0) {
+                        accumulate_cell(accumulator, data, (index - slice_size) * channels, channels);
+                        neighbour_count++;
+                    }
+
+                    if (z < size_z - 1 && source_coverage[index + slice_size] !== 0) {
+                        accumulate_cell(accumulator, data, (index + slice_size) * channels, channels);
+                        neighbour_count++;
+                    }
+
+                    if (neighbour_count === 0) {
+                        continue;
+                    }
+
+                    const address = index * channels;
+                    const inverse_count = 1 / neighbour_count;
+
+                    for (let c = 0; c < channels; c++) {
+                        data[address + c] = accumulator[c] * inverse_count;
+                    }
+
+                    coverage[index] = 1;
+                    filled_this_pass++;
+                }
+            }
+        }
+
+        if (filled_this_pass === 0) {
+            // nothing left to reach
+            break;
+        }
+
+        uncovered_count -= filled_this_pass;
+    }
+
+    return uncovered_count;
+}
+
+/**
+ * @param {Float64Array} accumulator
+ * @param {Float32Array|Float64Array|number[]} data
+ * @param {number} offset
+ * @param {number} channels
+ */
+function accumulate_cell(accumulator, data, offset, channels) {
+    for (let c = 0; c < channels; c++) {
+        accumulator[c] += data[offset + c];
+    }
+}

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/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"}

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

@@ -1,4 +1,4 @@
-import { insert_after } from "../../../../../../core/primitives/strings/insert_after.js";
+import { build_injected_shader, GLSL_ANCHOR_FOG_VERTEX } from "../../../build_injected_shader.js";
 
 //language=GLSL
 const PREAMBLE = `
@@ -37,13 +37,10 @@ const CAPTURE_WORLD_POSITION = `
  */
 export function build_vertex_shader(source) {
 
-    let result = PREAMBLE + source;
-
-    result = insert_after(
-        result,
-        '#include <fog_vertex>',
+    return build_injected_shader(
+        source,
+        PREAMBLE,
+        GLSL_ANCHOR_FOG_VERTEX,
         CAPTURE_WORLD_POSITION
     );
-
-    return result;
 }

package/src/engine/graphics/sh3/lpg/material/space_vertex/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_vertex/build_fragment_shader.js"],"names":[],"mappings":"AAcA;;;GAGG;AACH,8CAFW,MAAM,UAahB"}
+{"version":3,"file":"build_fragment_shader.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/sh3/lpg/material/space_vertex/build_fragment_shader.js"],"names":[],"mappings":"AAcA;;;GAGG;AACH,8CAFW,MAAM,UAUhB"}

package/src/engine/graphics/sh3/lpg/material/space_vertex/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 from "./preamble.frag.js";
 
 //language=GLSL
@@ -18,13 +18,10 @@ const ACCUMULATION = `
  */
 export function build_fragment_shader(source) {
 
-    let result = PREAMBLE + source;
-
-    result = insert_after(
-        result,
-        '#include <lights_fragment_begin>',
+    return build_injected_shader(
+        source,
+        PREAMBLE,
+        GLSL_ANCHOR_LIGHTS_FRAGMENT_BEGIN,
         ACCUMULATION
     );
-
-    return result;
 }

package/src/engine/graphics/sh3/lpg/material/space_vertex/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_vertex/build_vertex_shader.js"],"names":[],"mappings":"AAyBA;;;GAGG;AACH,4CAFW,MAAM,UAahB"}
+{"version":3,"file":"build_vertex_shader.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/sh3/lpg/material/space_vertex/build_vertex_shader.js"],"names":[],"mappings":"AAyBA;;;GAGG;AACH,4CAFW,MAAM,UAUhB"}

package/src/engine/graphics/sh3/lpg/material/space_vertex/build_vertex_shader.js

@@ -1,4 +1,4 @@
-import { insert_after } from "../../../../../../core/primitives/strings/insert_after.js";
+import { build_injected_shader, GLSL_ANCHOR_FOG_VERTEX } from "../../../build_injected_shader.js";
 import PREAMBLE_COMMON from "../common.js";
 import PREAMBLE from "./preamble.vert.js";
 
@@ -29,13 +29,10 @@ const SHADER_CHUNK_ACCUMULATION = `
  */
 export function build_vertex_shader(source) {
 
-    let result = PREAMBLE + PREAMBLE_COMMON + source;
-
-    result = insert_after(
-        result,
-        '#include <fog_vertex>',
+    return build_injected_shader(
+        source,
+        PREAMBLE + PREAMBLE_COMMON,
+        GLSL_ANCHOR_FOG_VERTEX,
         SHADER_CHUNK_ACCUMULATION
     );
-
-    return result;
 }