@woosh/meep-engine 2.169.1 → 2.169.2

package/src/engine/ui/apply_pointer_tilt_3d.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Write a mouse-parallax 3D tilt onto a DOM element.
+ *
+ * The element is rotated about an axis perpendicular to the pointer's offset from `pivot`, by an
+ * angle proportional to how far the pointer is from that pivot relative to half the viewport. The
+ * result reads as the element leaning away from / toward the cursor.
+ *
+ * This exists because the identical body was carried by both {@link GuiElementParallaxSystem} (ECS)
+ * and {@link DomElementProcessorTilt3D} (DOM binding), and the ECS copy had silently lost its pivot:
+ * it computed the element centre and then took the delta against the viewport centre instead, so
+ * every element tilted identically no matter where on screen it sat. There is one pivot convention
+ * now — the caller always supplies it, and it is always the element centre.
+ *
+ * @param {HTMLElement} el element to write the transform onto
+ * @param {number} pointer_x pointer position in viewport pixels
+ * @param {number} pointer_y
+ * @param {number} pivot_x point the tilt is measured from, in viewport pixels; normally the element centre
+ * @param {number} pivot_y
+ * @param {number} viewport_width used to normalise the pointer offset; must be greater than 0
+ * @param {number} viewport_height must be greater than 0
+ * @param {number} angle maximum tilt in degrees, reached when the pointer offset equals half the viewport
+ * @param {number} depth `translateZ` applied after the rotation, in pixels; 0 for a pure rotation
+ */
+export function apply_pointer_tilt_3d(el: HTMLElement, pointer_x: number, pointer_y: number, pivot_x: number, pivot_y: number, viewport_width: number, viewport_height: number, angle: number, depth: number): void;
+//# sourceMappingURL=apply_pointer_tilt_3d.d.ts.map

package/src/engine/ui/apply_pointer_tilt_3d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply_pointer_tilt_3d.d.ts","sourceRoot":"","sources":["../../../../src/engine/ui/apply_pointer_tilt_3d.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,0CAVW,WAAW,aACX,MAAM,aACN,MAAM,WACN,MAAM,WACN,MAAM,kBACN,MAAM,mBACN,MAAM,SACN,MAAM,SACN,MAAM,QA4BhB"}

package/src/engine/ui/apply_pointer_tilt_3d.js

@@ -0,0 +1,50 @@
+/**
+ * Write a mouse-parallax 3D tilt onto a DOM element.
+ *
+ * The element is rotated about an axis perpendicular to the pointer's offset from `pivot`, by an
+ * angle proportional to how far the pointer is from that pivot relative to half the viewport. The
+ * result reads as the element leaning away from / toward the cursor.
+ *
+ * This exists because the identical body was carried by both {@link GuiElementParallaxSystem} (ECS)
+ * and {@link DomElementProcessorTilt3D} (DOM binding), and the ECS copy had silently lost its pivot:
+ * it computed the element centre and then took the delta against the viewport centre instead, so
+ * every element tilted identically no matter where on screen it sat. There is one pivot convention
+ * now — the caller always supplies it, and it is always the element centre.
+ *
+ * @param {HTMLElement} el element to write the transform onto
+ * @param {number} pointer_x pointer position in viewport pixels
+ * @param {number} pointer_y
+ * @param {number} pivot_x point the tilt is measured from, in viewport pixels; normally the element centre
+ * @param {number} pivot_y
+ * @param {number} viewport_width used to normalise the pointer offset; must be greater than 0
+ * @param {number} viewport_height must be greater than 0
+ * @param {number} angle maximum tilt in degrees, reached when the pointer offset equals half the viewport
+ * @param {number} depth `translateZ` applied after the rotation, in pixels; 0 for a pure rotation
+ */
+export function apply_pointer_tilt_3d(
+    el,
+    pointer_x, pointer_y,
+    pivot_x, pivot_y,
+    viewport_width, viewport_height,
+    angle,
+    depth
+) {
+
+    const viewport_center_x = viewport_width * 0.5;
+    const viewport_center_y = viewport_height * 0.5;
+
+    const delta_x = pointer_x - pivot_x;
+    const delta_y = pointer_y - pivot_y;
+
+    const tilt_x = (delta_y / viewport_center_y);
+    const tilt_y = -(delta_x / viewport_center_x);
+
+    const radius = Math.sqrt(tilt_x * tilt_x + tilt_y * tilt_y);
+
+    const tilt_angle = radius * angle;
+
+    const style = el.style;
+
+    style.transformOrigin = '50% 50%';
+    style.transform = `rotate3d(${tilt_x},${tilt_y},0,${tilt_angle}deg) translateZ(${depth}px)`;
+}

package/src/engine/ui/bindings/processors/DomElementProcessorTilt3D.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DomElementProcessorTilt3D.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ui/bindings/processors/DomElementProcessorTilt3D.js"],"names":[],"mappings":"AAEA;IAuBI;;;;;OAKG;IACH,+BAJW,MAAM,GAEL,yBAAyB,CAcpC;IArCG;;;OAGG;IACH,OAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,OAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,eAAkB;IAuBtB,+BAEC;CAmDJ;oCAlGmC,2BAA2B"}
+{"version":3,"file":"DomElementProcessorTilt3D.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ui/bindings/processors/DomElementProcessorTilt3D.js"],"names":[],"mappings":"AAGA;IAuBI;;;;;OAKG;IACH,+BAJW,MAAM,GAEL,yBAAyB,CAcpC;IArCG;;;OAGG;IACH,OAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,OAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,eAAkB;IAuBtB,+BAEC;CAiCJ;oCAhFmC,2BAA2B"}

package/src/engine/ui/bindings/processors/DomElementProcessorTilt3D.js

@@ -1,3 +1,4 @@
+import { apply_pointer_tilt_3d } from "../../apply_pointer_tilt_3d.js";
 import { DomElementProcessor } from "../DomElementProcessor.js";
 
 export class DomElementProcessorTilt3D extends DomElementProcessor {
@@ -61,9 +62,6 @@ export class DomElementProcessorTilt3D extends DomElementProcessor {
 
         const p = engine.devices.pointer.position;
 
-        const pointer_x = p.x;
-        const pointer_y = p.y;
-
         const viewport_size = engine.gameView.size;
 
         /**
@@ -72,28 +70,13 @@ export class DomElementProcessorTilt3D extends DomElementProcessor {
          */
         const rect = el.getBoundingClientRect();
 
-        const center_x = rect.left + rect.width * 0.5;
-        const center_y = rect.top + rect.height * 0.5;
-
-
-        const viewport_center_x = viewport_size.x * 0.5;
-        const viewport_center_y = viewport_size.y * 0.5;
-
-        const delta_x = pointer_x - center_x;
-        const delta_y = pointer_y - center_y;
-
-
-        const tilt_x = (delta_y / viewport_center_y);
-        const tilt_y = -(delta_x / viewport_center_x);
-
-        const radius = Math.sqrt(tilt_x * tilt_x + tilt_y * tilt_y);
-
-        const angle = radius * this.angle;
-
-
-        const style = el.style;
-
-        style.transformOrigin = '50% 50%';
-        style.transform = `rotate3d(${tilt_x},${tilt_y},0,${angle}deg) translateZ(${this.depth}px)`;
+        apply_pointer_tilt_3d(
+            el,
+            p.x, p.y,
+            rect.left + rect.width * 0.5, rect.top + rect.height * 0.5,
+            viewport_size.x, viewport_size.y,
+            this.angle,
+            this.depth
+        );
     }
 }

package/src/generation/filtering/numeric/CellFilterCache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CellFilterCache.d.ts","sourceRoot":"","sources":["../../../../../src/generation/filtering/numeric/CellFilterCache.js"],"names":[],"mappings":"AAIA;IAeI;;;;;OAKG;IACH,wCAHW,MAAM,GACJ,eAAe,CAW3B;IA5BD;;;;OAIG;IACH,gBAAqC;IAErC;;;OAGG;IACH,OAFU,MAAM,CAEN;IAmBV,uCAkCC;CAKJ;yCAzEwC,qCAAqC"}
+{"version":3,"file":"CellFilterCache.d.ts","sourceRoot":"","sources":["../../../../../src/generation/filtering/numeric/CellFilterCache.js"],"names":[],"mappings":"AAKA;IAeI;;;;;OAKG;IACH,wCAHW,MAAM,GACJ,eAAe,CAW3B;IA5BD;;;;OAIG;IACH,gBAAqC;IAErC;;;OAGG;IACH,OAFU,MAAM,CAEN;IAmBV,uCAgBC;CAKJ;yCAxDwC,qCAAqC"}

package/src/generation/filtering/numeric/CellFilterCache.js

@@ -1,6 +1,7 @@
 import { assert } from "../../../core/assert.js";
 import { Sampler2D } from "../../../engine/graphics/texture/sampler/Sampler2D.js";
 import { CellFilterUnaryOperation } from "../core/CellFilterUnaryOperation.js";
+import { write_cell_filter_to_sampler2d } from "./util/write_cell_filter_to_sampler2d.js";
 
 export class CellFilterCache extends CellFilterUnaryOperation {
 
@@ -43,31 +44,13 @@ export class CellFilterCache extends CellFilterUnaryOperation {
         const target_w = this.scale * g_w;
         const target_h = this.scale * g_h;
 
-        const source = this.source;
         const cache = this.__cache;
 
         cache.resize(target_w, target_h);
 
-        const scale_1 = 1 / this.scale;
-
-        // console.time('Cache filter build');
-
-        let x = 0;
-        let y = 0;
-
-        for (y = 0; y < target_h; y++) {
-            const grid_y = y * scale_1;
-
-            for (x = 0; x < target_w; x++) {
-                const grid_x = x * scale_1;
-
-                const sampleValue = source.execute(grid, grid_x, grid_y, 0);
-
-                cache.writeChannel(x, y, 0, sampleValue);
-            }
-        }
-
-        // console.timeEnd('Cache filter build');
+        // the source has already been initialized by `super.initialize`, so this must not go through
+        // `populateSampler2DFromCellFilter` (which would re-initialize it with seed 0)
+        write_cell_filter_to_sampler2d(cache, this.source, grid);
     }
 
     execute(grid, x, y, rotation) {

package/src/generation/filtering/numeric/complex/CellFilterSobel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CellFilterSobel.d.ts","sourceRoot":"","sources":["../../../../../../src/generation/filtering/numeric/complex/CellFilterSobel.js"],"names":[],"mappings":"AAGA;;GAEG;AACH;IAaI;;;;OAIG;IACH,oBAHW,UAAU,GACR,eAAe,CAU3B;IAxBD;;;OAGG;IACH,QAFU,UAAU,CAEN;IAsBd,0DAuBC;CACJ;2BA1D0B,qBAAqB"}
+{"version":3,"file":"CellFilterSobel.d.ts","sourceRoot":"","sources":["../../../../../../src/generation/filtering/numeric/complex/CellFilterSobel.js"],"names":[],"mappings":"AAWA;;GAEG;AACH;IAaI;;;;OAIG;IACH,oBAHW,UAAU,GACR,eAAe,CAU3B;IAxBD;;;OAGG;IACH,QAFU,UAAU,CAEN;IAsBd,0DAMC;CACJ;2BAjD0B,qBAAqB"}

package/src/generation/filtering/numeric/complex/CellFilterSobel.js

@@ -1,5 +1,13 @@
 import { CellFilter } from "../../CellFilter.js";
 import { assert } from "../../../../core/assert.js";
+import { v2_length } from "../../../../core/geom/vec2/v2_length.js";
+import { computeCellFilterSobel } from "../process/computeCellFilterSobel.js";
+
+/**
+ * Scratch for the raw gradient. Read out before returning, so it cannot alias across nested filters.
+ * @type {Float64Array}
+ */
+const scratch_gradient = new Float64Array(2);
 
 /**
  * Sobel edge-detection filter
@@ -33,27 +41,10 @@ export class CellFilterSobel extends CellFilter {
     }
 
     execute(grid, x, y, rotation) {
-        const filter = this.source;
-
-        //read surrounding points
-        const topLeft = filter.execute(grid, x - 1, y - 1, 0);
-        const top = filter.execute(grid, x, y - 1, 0);
-        const topRight = filter.execute(grid, x + 1, y - 1, 0);
-
-        const left = filter.execute(grid, x - 1, y, 0);
-        const right = filter.execute(grid, x + 1, y, 0);
-
-        const bottomLeft = filter.execute(grid, x - 1, y + 1, 0);
-        const bottom = filter.execute(grid, x, y + 1, 0);
-        const bottomRight = filter.execute(grid, x + 1, y + 1, 0);
-
-        // compute gradients
-        const dX = (topRight + 2.0 * right + bottomRight) - (topLeft + 2.0 * left + bottomLeft);
-        const dY = (bottomLeft + 2.0 * bottom + bottomRight) - (topLeft + 2.0 * top + topRight);
 
-        //normalize vector
-        const magnitude = Math.sqrt(dX * dX + dY * dY);
+        computeCellFilterSobel(scratch_gradient, 0, this.source, grid, x, y);
 
-        return magnitude;
+        //edge strength is the gradient magnitude, the direction is discarded
+        return v2_length(scratch_gradient[0], scratch_gradient[1]);
     }
 }

package/src/generation/filtering/numeric/math/CellFilterPower.d.ts

@@ -6,7 +6,7 @@ export class CellFilterPower extends CellFilterBinaryOperation {
      * @returns {CellFilterPower}
      */
     static from(value: CellFilter, power: CellFilter): CellFilterPower;
-    execute(grid: any, x: any, y: any, rotation: any): number;
+    operation(value: any, power: any): number;
 }
 import { CellFilterBinaryOperation } from "../../core/CellFilterBinaryOperation.js";
 //# sourceMappingURL=CellFilterPower.d.ts.map

package/src/generation/filtering/numeric/math/CellFilterPower.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CellFilterPower.d.ts","sourceRoot":"","sources":["../../../../../../src/generation/filtering/numeric/math/CellFilterPower.js"],"names":[],"mappings":"AAGA;IAGI;;;;;OAKG;IACH,mDAFa,eAAe,CAY3B;IAED,0DAKC;CACJ;0CA9ByC,yCAAyC"}
+{"version":3,"file":"CellFilterPower.d.ts","sourceRoot":"","sources":["../../../../../../src/generation/filtering/numeric/math/CellFilterPower.js"],"names":[],"mappings":"AAGA;IAEI;;;;;OAKG;IACH,mDAFa,eAAe,CAY3B;IAED,0CAEC;CACJ;0CA1ByC,yCAAyC"}

package/src/generation/filtering/numeric/math/CellFilterPower.js

@@ -3,7 +3,6 @@ import { assert } from "../../../../core/assert.js";
 
 export class CellFilterPower extends CellFilterBinaryOperation {
 
-
     /**
      *
      * @param {CellFilter} value
@@ -22,10 +21,7 @@ export class CellFilterPower extends CellFilterBinaryOperation {
         return r;
     }
 
-    execute(grid, x, y, rotation) {
-        const value = this.left.execute(grid, x, y, rotation);
-        const power = this.right.execute(grid, x, y, rotation);
-
+    operation(value, power) {
         return Math.pow(value, power);
     }
 }

package/src/generation/filtering/numeric/process/computeCellFilterGradient.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"computeCellFilterGradient.d.ts","sourceRoot":"","sources":["../../../../../../src/generation/filtering/numeric/process/computeCellFilterGradient.js"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,kDATW,MAAM,EAAE,KACR,MAAM,KACN,MAAM,uCAKJ,OAAO,CAsCnB"}
+{"version":3,"file":"computeCellFilterGradient.d.ts","sourceRoot":"","sources":["../../../../../../src/generation/filtering/numeric/process/computeCellFilterGradient.js"],"names":[],"mappings":"AASA;;;;;;;;;;GAUG;AACH,kDATW,MAAM,EAAE,KACR,MAAM,KACN,MAAM,uCAKJ,OAAO,CA2BnB"}

package/src/generation/filtering/numeric/process/computeCellFilterGradient.js

@@ -1,3 +1,12 @@
+import { v2_length } from "../../../../core/geom/vec2/v2_length.js";
+import { computeCellFilterSobel } from "./computeCellFilterSobel.js";
+
+/**
+ * Scratch for the raw gradient. Read out before `result` is written, so `result` may alias it.
+ * @type {Float64Array}
+ */
+const scratch_gradient = new Float64Array(2);
+
 /**
  *
  * @param {number[]} result
@@ -11,24 +20,13 @@
  */
 export function computeCellFilterGradient(result, x, y, filter, grid) {
 
-    //read surrounding points
-    const topLeft = filter.execute(grid, x - 1, y - 1, 0);
-    const top = filter.execute(grid, x, y - 1, 0);
-    const topRight = filter.execute(grid, x + 1, y - 1, 0);
-
-    const left = filter.execute(grid, x - 1, y, 0);
-    const right = filter.execute(grid, x + 1, y, 0);
-
-    const bottomLeft = filter.execute(grid, x - 1, y + 1, 0);
-    const bottom = filter.execute(grid, x, y + 1, 0);
-    const bottomRight = filter.execute(grid, x + 1, y + 1, 0);
+    computeCellFilterSobel(scratch_gradient, 0, filter, grid, x, y);
 
-    // compute gradients
-    const dX = (topRight + 2.0 * right + bottomRight) - (topLeft + 2.0 * left + bottomLeft);
-    const dY = (bottomLeft + 2.0 * bottom + bottomRight) - (topLeft + 2.0 * top + topRight);
+    const dX = scratch_gradient[0];
+    const dY = scratch_gradient[1];
 
     //normalize vector
-    const magnitude = Math.sqrt(dX * dX + dY * dY);
+    const magnitude = v2_length(dX, dY);
 
     if (magnitude === 0) {
         result[0] = 0;

package/src/generation/filtering/numeric/process/computeCellFilterSobel.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Apply the 3x3 Sobel operator to a {@link CellFilter} at a grid position, writing the raw
+ * (un-normalized) gradient vector into `result`.
+ *
+ * This exists so that the eight-tap read and the operator's kernel weights have a single
+ * definition: everything downstream of the taps (magnitude, direction, thresholding) differs
+ * between callers, but the taps themselves must not.
+ *
+ * The source filter is sampled at rotation 0 — the operator is defined in grid space, so rotating
+ * the taps would rotate the reported gradient with them and cancel out.
+ *
+ * @param {Float64Array|Float32Array|number[]} result receives `[dX, dY]`
+ * @param {number} result_offset
+ * @param {CellFilter} filter
+ * @param {GridData} grid
+ * @param {number} x
+ * @param {number} y
+ */
+export function computeCellFilterSobel(result: Float64Array | Float32Array | number[], result_offset: number, filter: CellFilter, grid: GridData, x: number, y: number): void;
+//# sourceMappingURL=computeCellFilterSobel.d.ts.map

package/src/generation/filtering/numeric/process/computeCellFilterSobel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"computeCellFilterSobel.d.ts","sourceRoot":"","sources":["../../../../../../src/generation/filtering/numeric/process/computeCellFilterSobel.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,+CAPW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,iBAClC,MAAM,yCAGN,MAAM,KACN,MAAM,QAmBhB"}

package/src/generation/filtering/numeric/process/computeCellFilterSobel.js

@@ -0,0 +1,36 @@
+/**
+ * Apply the 3x3 Sobel operator to a {@link CellFilter} at a grid position, writing the raw
+ * (un-normalized) gradient vector into `result`.
+ *
+ * This exists so that the eight-tap read and the operator's kernel weights have a single
+ * definition: everything downstream of the taps (magnitude, direction, thresholding) differs
+ * between callers, but the taps themselves must not.
+ *
+ * The source filter is sampled at rotation 0 — the operator is defined in grid space, so rotating
+ * the taps would rotate the reported gradient with them and cancel out.
+ *
+ * @param {Float64Array|Float32Array|number[]} result receives `[dX, dY]`
+ * @param {number} result_offset
+ * @param {CellFilter} filter
+ * @param {GridData} grid
+ * @param {number} x
+ * @param {number} y
+ */
+export function computeCellFilterSobel(result, result_offset, filter, grid, x, y) {
+
+    //read surrounding points
+    const topLeft = filter.execute(grid, x - 1, y - 1, 0);
+    const top = filter.execute(grid, x, y - 1, 0);
+    const topRight = filter.execute(grid, x + 1, y - 1, 0);
+
+    const left = filter.execute(grid, x - 1, y, 0);
+    const right = filter.execute(grid, x + 1, y, 0);
+
+    const bottomLeft = filter.execute(grid, x - 1, y + 1, 0);
+    const bottom = filter.execute(grid, x, y + 1, 0);
+    const bottomRight = filter.execute(grid, x + 1, y + 1, 0);
+
+    // compute gradients
+    result[result_offset] = (topRight + 2.0 * right + bottomRight) - (topLeft + 2.0 * left + bottomLeft);
+    result[result_offset + 1] = (bottomLeft + 2.0 * bottom + bottomRight) - (topLeft + 2.0 * top + topRight);
+}

package/src/generation/filtering/numeric/util/CellFilterDisplaced.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CellFilterDisplaced.d.ts","sourceRoot":"","sources":["../../../../../../src/generation/filtering/numeric/util/CellFilterDisplaced.js"],"names":[],"mappings":"AAIA;IAQI;;;;;;OAMG;IACH,mCAJW,MAAM,KACN,MAAM,GACL,mBAAmB,CAW9B;IAvBD;;;OAGG;IACH,iBAFU,OAAO,CAEM;CAmC1B;yCA5CwC,wCAAwC;oBAC7D,kCAAkC"}
+{"version":3,"file":"CellFilterDisplaced.d.ts","sourceRoot":"","sources":["../../../../../../src/generation/filtering/numeric/util/CellFilterDisplaced.js"],"names":[],"mappings":"AAWA;IAQI;;;;;;OAMG;IACH,mCAJW,MAAM,KACN,MAAM,GACL,mBAAmB,CAW9B;IAvBD;;;OAGG;IACH,iBAFU,OAAO,CAEM;CAiC1B;yCAjDwC,wCAAwC;oBAC7D,kCAAkC"}

package/src/generation/filtering/numeric/util/CellFilterDisplaced.js

@@ -1,7 +1,14 @@
 import { CellFilterUnaryOperation } from "../../core/CellFilterUnaryOperation.js";
 import Vector2 from "../../../../core/geom/Vector2.js";
+import { v2_rotate } from "../../../../core/geom/vec2/v2_rotate.js";
 import { assert } from "../../../../core/assert.js";
 
+/**
+ * Scratch for the rotated offset. Read out before any nested filter call, so it cannot alias.
+ * @type {Float64Array}
+ */
+const scratch_offset = new Float64Array(2);
+
 export class CellFilterDisplaced extends CellFilterUnaryOperation {
     /**
      * @readonly
@@ -30,14 +37,12 @@ export class CellFilterDisplaced extends CellFilterUnaryOperation {
 
     execute(grid, x, y, rotation) {
 
-        const sin = Math.sin(rotation);
-        const cos = Math.cos(rotation);
+        const offset = this.offset;
 
-        const local_x = this.offset.x;
-        const local_y = this.offset.y;
+        v2_rotate(scratch_offset, 0, offset.x, offset.y, rotation);
 
-        const rotated_local_x = local_x * cos - local_y * sin
-        const rotated_local_y = local_x * sin + local_y * cos;
+        const rotated_local_x = scratch_offset[0];
+        const rotated_local_y = scratch_offset[1];
 
         return this.source.execute(grid, x + rotated_local_x, y + rotated_local_y, rotation);
 

package/src/generation/filtering/numeric/util/populateSampler2DFromCellFilter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"populateSampler2DFromCellFilter.d.ts","sourceRoot":"","sources":["../../../../../../src/generation/filtering/numeric/util/populateSampler2DFromCellFilter.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,2FA2BC"}
+{"version":3,"file":"populateSampler2DFromCellFilter.d.ts","sourceRoot":"","sources":["../../../../../../src/generation/filtering/numeric/util/populateSampler2DFromCellFilter.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,2FAQC"}

package/src/generation/filtering/numeric/util/populateSampler2DFromCellFilter.js

@@ -1,36 +1,18 @@
-import { assert } from "../../../../core/assert.js";
-
-/**
- * Utility function, mainly useful for visualizing filter values
- * @param {Sampler2D} result
- * @param {CellFilter} filter
- * @param {GridData} grid
- */
-export function populateSampler2DFromCellFilter({ result, filter, grid }) {
-    assert.defined(result,'result');
-    assert.defined(filter,'filter');
-    assert.defined(grid,'grid');
-
-    filter.ensureInitialized(grid, 0);
-
-    // ratio mapping, texel t of the result represents grid t / scale (see generation/COORDINATES.md)
-    const scale_x = result.width / grid.width;
-    const scale_y = result.height / grid.height;
-
-    const result_height = result.height;
-
-    for (let y = 0; y < result_height; y++) {
-
-        const grid_y = y / scale_y;
-
-        for (let x = 0; x < result.width; x++) {
-
-            const grid_x = x / scale_x;
-
-            const filterValue = filter.execute(grid, grid_x, grid_y, 0);
-
-            result.writeChannel(x, y, 0, filterValue);
-
-        }
-    }
-}
+import { assert } from "../../../../core/assert.js";
+import { write_cell_filter_to_sampler2d } from "./write_cell_filter_to_sampler2d.js";
+
+/**
+ * Utility function, mainly useful for visualizing filter values
+ * @param {Sampler2D} result
+ * @param {CellFilter} filter
+ * @param {GridData} grid
+ */
+export function populateSampler2DFromCellFilter({ result, filter, grid }) {
+    assert.defined(result,'result');
+    assert.defined(filter,'filter');
+    assert.defined(grid,'grid');
+
+    filter.ensureInitialized(grid, 0);
+
+    write_cell_filter_to_sampler2d(result, filter, grid);
+}

package/src/generation/filtering/numeric/util/write_cell_filter_to_sampler2d.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Rasterize a {@link CellFilter} into channel 0 of a {@link Sampler2D} that covers the whole grid.
+ *
+ * The sampler may be at a different resolution than the grid; the mapping is the plain ratio
+ * (texel t of the result represents grid `t / scale`, see `generation/COORDINATES.md`). That
+ * convention is the reason this lives in one place: every rasterization of a filter must agree with
+ * it, and a second hand-rolled loop is a second place for it to drift.
+ *
+ * The filter must already be initialized — this function deliberately does not call
+ * `ensureInitialized`, so that callers rasterizing during their own `initialize` (where the source
+ * has already been initialized with the real seed) are not forced through a seed-0 re-initialize.
+ *
+ * The filter is evaluated at rotation 0: a raster covers the grid in grid space, there is no
+ * placement orientation to propagate.
+ *
+ * @param {Sampler2D} result
+ * @param {CellFilter} filter
+ * @param {GridData} grid
+ */
+export function write_cell_filter_to_sampler2d(result: Sampler2D, filter: CellFilter, grid: GridData): void;
+//# sourceMappingURL=write_cell_filter_to_sampler2d.d.ts.map

package/src/generation/filtering/numeric/util/write_cell_filter_to_sampler2d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"write_cell_filter_to_sampler2d.d.ts","sourceRoot":"","sources":["../../../../../../src/generation/filtering/numeric/util/write_cell_filter_to_sampler2d.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;GAkBG;AACH,4GAyBC"}

package/src/generation/filtering/numeric/util/write_cell_filter_to_sampler2d.js

@@ -0,0 +1,47 @@
+import { assert } from "../../../../core/assert.js";
+
+/**
+ * Rasterize a {@link CellFilter} into channel 0 of a {@link Sampler2D} that covers the whole grid.
+ *
+ * The sampler may be at a different resolution than the grid; the mapping is the plain ratio
+ * (texel t of the result represents grid `t / scale`, see `generation/COORDINATES.md`). That
+ * convention is the reason this lives in one place: every rasterization of a filter must agree with
+ * it, and a second hand-rolled loop is a second place for it to drift.
+ *
+ * The filter must already be initialized — this function deliberately does not call
+ * `ensureInitialized`, so that callers rasterizing during their own `initialize` (where the source
+ * has already been initialized with the real seed) are not forced through a seed-0 re-initialize.
+ *
+ * The filter is evaluated at rotation 0: a raster covers the grid in grid space, there is no
+ * placement orientation to propagate.
+ *
+ * @param {Sampler2D} result
+ * @param {CellFilter} filter
+ * @param {GridData} grid
+ */
+export function write_cell_filter_to_sampler2d(result, filter, grid) {
+    assert.defined(result, 'result');
+    assert.defined(filter, 'filter');
+    assert.defined(grid, 'grid');
+
+    const result_width = result.width;
+    const result_height = result.height;
+
+    const scale_x = result_width / grid.width;
+    const scale_y = result_height / grid.height;
+
+    for (let y = 0; y < result_height; y++) {
+
+        const grid_y = y / scale_y;
+
+        for (let x = 0; x < result_width; x++) {
+
+            const grid_x = x / scale_x;
+
+            const filterValue = filter.execute(grid, grid_x, grid_y, 0);
+
+            result.writeChannel(x, y, 0, filterValue);
+
+        }
+    }
+}

package/src/generation/filtering/util/cell_filter_weights_pick.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Pick one element out of a set of {@link CellFilter}-weighted alternatives, evaluating each weight
+ * at a single grid position.
+ *
+ * This exists because the weighted-alternative combinator is written once per node hierarchy
+ * (`MarkerNodeAction`, `GridCellAction`, ...) and the *shape* of those classes is deliberately
+ * duplicated, but the selection *logic* — evaluating the weights, clamping negatives, building the
+ * CDF and the "nothing is selectable here" contract — is not, and must stay identical between them.
+ *
+ * Weight filters are always evaluated at rotation 0: a weight is a property of the position, not of
+ * the orientation the alternative will eventually be placed with.
+ *
+ * @param {function():number} random RNG returning values in [0, 1). Consumed exactly once, and only
+ * when at least one element carries positive weight.
+ * @param {{weight:CellFilter}[]} elements weighted alternatives, in a stable order
+ * @param {GridData} grid
+ * @param {number} x
+ * @param {number} y
+ * @returns {number} index into `elements`, or -1 when every element has zero weight at this
+ * position — in which case the caller must select nothing rather than fall back to a uniform pick
+ */
+export function cell_filter_weights_pick(random: () => number, elements: {
+    weight: CellFilter;
+}[], grid: GridData, x: number, y: number): number;
+//# sourceMappingURL=cell_filter_weights_pick.d.ts.map

package/src/generation/filtering/util/cell_filter_weights_pick.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cell_filter_weights_pick.d.ts","sourceRoot":"","sources":["../../../../../src/generation/filtering/util/cell_filter_weights_pick.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,uDATsB,MAAM,YAEjB;IAAC,MAAM,aAAW;CAAC,EAAE,qBAErB,MAAM,KACN,MAAM,GACJ,MAAM,CAsBlB"}

package/src/generation/filtering/util/cell_filter_weights_pick.js

@@ -0,0 +1,54 @@
+import { random_pick_weighted_index } from "../../../core/math/random/random_pick_weighted_index.js";
+
+/**
+ * Cumulative (inclusive prefix-sum) weight scratch.
+ *
+ * Shared across all callers because the pick is a single synchronous span: the weights are produced
+ * by {@link CellFilter#execute}, which evaluates the filter graph only and cannot re-enter an
+ * action, and the selected action is invoked after the pick has returned.
+ *
+ * @type {number[]}
+ */
+const cumulative_weights = [];
+
+/**
+ * Pick one element out of a set of {@link CellFilter}-weighted alternatives, evaluating each weight
+ * at a single grid position.
+ *
+ * This exists because the weighted-alternative combinator is written once per node hierarchy
+ * (`MarkerNodeAction`, `GridCellAction`, ...) and the *shape* of those classes is deliberately
+ * duplicated, but the selection *logic* — evaluating the weights, clamping negatives, building the
+ * CDF and the "nothing is selectable here" contract — is not, and must stay identical between them.
+ *
+ * Weight filters are always evaluated at rotation 0: a weight is a property of the position, not of
+ * the orientation the alternative will eventually be placed with.
+ *
+ * @param {function():number} random RNG returning values in [0, 1). Consumed exactly once, and only
+ * when at least one element carries positive weight.
+ * @param {{weight:CellFilter}[]} elements weighted alternatives, in a stable order
+ * @param {GridData} grid
+ * @param {number} x
+ * @param {number} y
+ * @returns {number} index into `elements`, or -1 when every element has zero weight at this
+ * position — in which case the caller must select nothing rather than fall back to a uniform pick
+ */
+export function cell_filter_weights_pick(random, elements, grid, x, y) {
+
+    const n = elements.length;
+
+    let totalWeight = 0;
+
+    for (let i = 0; i < n; i++) {
+
+        const weightValue = elements[i].weight.execute(grid, x, y, 0);
+
+        if (weightValue > 0) {
+            //if the weight is negative, we clamp it to 0
+            totalWeight += weightValue;
+        }
+
+        cumulative_weights[i] = totalWeight;
+    }
+
+    return random_pick_weighted_index(random, cumulative_weights, n);
+}