@woosh/meep-engine 2.156.0 → 2.157.0

package/src/generation/filtering/core/CellFilterOperationTertiary.js

@@ -1,59 +1,43 @@
-import { CellFilter } from "../CellFilter.js";
-
-export class CellFilterOperationTertiary extends CellFilter {
-
-    /**
-     *
-     * @type {CellFilter}
-     */
-    a = null;
-    /**
-     *
-     * @type {CellFilter}
-     */
-    b = null;
-    /**
-     *
-     * @type {CellFilter}
-     */
-    c = null;
-
-    /**
-     *
-     * @param {number} a
-     * @param {number} b
-     * @param {number} c
-     * @returns {number}
-     */
-    operation(a, b, c) {
-        throw new Error('Not implemented');
-    }
-
-    initialize(grid, seed) {
-        if (this.initialized) {
-            return;
-        }
-
-        super.initialize(grid, seed);
-
-        if (!this.a.initialized) {
-            this.a.initialize(grid, seed);
-        }
-
-        if (!this.b.initialized) {
-            this.b.initialize(grid, seed);
-        }
-
-        if (!this.c.initialized) {
-            this.c.initialize(grid, seed);
-        }
-    }
-
-    execute(grid, x, y, rotation) {
-        const a = this.a.execute(grid, x, y, rotation);
-        const b = this.b.execute(grid, x, y, rotation);
-        const c = this.c.execute(grid, x, y, rotation);
-
-        return this.operation(a, b, c);
-    }
-}
+import { CellFilter } from "../CellFilter.js";
+
+export class CellFilterOperationTertiary extends CellFilter {
+
+    /**
+     *
+     * @type {CellFilter}
+     */
+    a = null;
+    /**
+     *
+     * @type {CellFilter}
+     */
+    b = null;
+    /**
+     *
+     * @type {CellFilter}
+     */
+    c = null;
+
+    get children() {
+        return [this.a, this.b, this.c];
+    }
+
+    /**
+     *
+     * @param {number} a
+     * @param {number} b
+     * @param {number} c
+     * @returns {number}
+     */
+    operation(a, b, c) {
+        throw new Error('Not implemented');
+    }
+
+    execute(grid, x, y, rotation) {
+        const a = this.a.execute(grid, x, y, rotation);
+        const b = this.b.execute(grid, x, y, rotation);
+        const c = this.c.execute(grid, x, y, rotation);
+
+        return this.operation(a, b, c);
+    }
+}

package/src/generation/filtering/core/CellFilterUnaryOperation.d.ts

@@ -10,7 +10,6 @@ export class CellFilterUnaryOperation extends CellFilter {
      * @returns {number}
      */
     operation(v: number): number;
-    initialize(grid: any, seed: any): void;
     execute(grid: any, x: any, y: any, rotation: any): number;
 }
 import { CellFilter } from "../CellFilter.js";

package/src/generation/filtering/core/CellFilterUnaryOperation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CellFilterUnaryOperation.d.ts","sourceRoot":"","sources":["../../../../../src/generation/filtering/core/CellFilterUnaryOperation.js"],"names":[],"mappings":"AAEA;IAEI;;;OAGG;IACH,QAFU,UAAU,CAEN;IAEd;;;;OAIG;IACH,aAHW,MAAM,GACJ,MAAM,CAIlB;IAED,uCAMC;IAED,0DAIC;CACJ;2BAhC0B,kBAAkB"}
+{"version":3,"file":"CellFilterUnaryOperation.d.ts","sourceRoot":"","sources":["../../../../../src/generation/filtering/core/CellFilterUnaryOperation.js"],"names":[],"mappings":"AAEA;IAEI;;;OAGG;IACH,QAFU,UAAU,CAEN;IAMd;;;;OAIG;IACH,aAHW,MAAM,GACJ,MAAM,CAIlB;IAED,0DAIC;CACJ;2BA5B0B,kBAAkB"}

package/src/generation/filtering/core/CellFilterUnaryOperation.js

@@ -1,33 +1,29 @@
-import { CellFilter } from "../CellFilter.js";
-
-export class CellFilterUnaryOperation extends CellFilter {
-
-    /**
-     *
-     * @type {CellFilter}
-     */
-    source = null;
-
-    /**
-     *
-     * @param {number} v
-     * @returns {number}
-     */
-    operation(v) {
-        throw new Error('Not implemented');
-    }
-
-    initialize(grid, seed) {
-        super.initialize(grid, seed);
-
-        if (!this.source.initialized) {
-            this.source.initialize(grid, seed);
-        }
-    }
-
-    execute(grid, x, y, rotation) {
-        const s = this.source.execute(grid, x, y, rotation);
-
-        return this.operation(s);
-    }
-}
+import { CellFilter } from "../CellFilter.js";
+
+export class CellFilterUnaryOperation extends CellFilter {
+
+    /**
+     *
+     * @type {CellFilter}
+     */
+    source = null;
+
+    get children() {
+        return [this.source];
+    }
+
+    /**
+     *
+     * @param {number} v
+     * @returns {number}
+     */
+    operation(v) {
+        throw new Error('Not implemented');
+    }
+
+    execute(grid, x, y, rotation) {
+        const s = this.source.execute(grid, x, y, rotation);
+
+        return this.operation(s);
+    }
+}

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

@@ -17,6 +17,7 @@ export class CellFilterCache extends CellFilterUnaryOperation {
      * @type {number}
      */
     scale: number;
+    initialize(grid: any, seed: any): void;
 }
 import { CellFilterUnaryOperation } from "../core/CellFilterUnaryOperation.js";
 //# sourceMappingURL=CellFilterCache.d.ts.map

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;CA0Db;yCAzEwC,qCAAqC"}
+{"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"}

package/src/generation/filtering/numeric/complex/CellFilterAngleToNormal.d.ts

@@ -1,5 +1,7 @@
 /**
- * Builds surface normal of another filter, and then computes the angle to a fixed 3d vector
+ * Builds surface normal of another filter, and then computes the angle to a fixed 3d vector.
+ * Normal convention is that of {@link computeFilterSurfaceNormal}: z is up, a surface rising
+ * along +x has a normal tilting towards -x.
  */
 export class CellFilterAngleToNormal extends CellFilter {
     /**
@@ -19,7 +21,6 @@ export class CellFilterAngleToNormal extends CellFilter {
      * @type {CellFilter}
      */
     surface: CellFilter;
-    initialize(grid: any, seed: any): void;
     execute(grid: any, x: any, y: any, rotation: any): number;
 }
 import { CellFilter } from "../../CellFilter.js";

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

@@ -1 +1 @@
-{"version":3,"file":"CellFilterAngleToNormal.d.ts","sourceRoot":"","sources":["../../../../../../src/generation/filtering/numeric/complex/CellFilterAngleToNormal.js"],"names":[],"mappings":"AAWA;;GAEG;AACH;IAiBI;;;;;OAKG;IACH,qBAJW,UAAU,cACV,OAAO,GACL,uBAAuB,CAWnC;IA5BG;;;OAGG;IACH,WAFU,OAAO,CAEoB;IAErC;;;OAGG;IACH,SAFU,UAAU,CAED;IAoBvB,uCAMC;IAED,0DA2BC;CACJ;2BApF0B,qBAAqB;oBAC5B,kCAAkC"}
+{"version":3,"file":"CellFilterAngleToNormal.d.ts","sourceRoot":"","sources":["../../../../../../src/generation/filtering/numeric/complex/CellFilterAngleToNormal.js"],"names":[],"mappings":"AAQA;;;;GAIG;AACH;IAiBI;;;;;OAKG;IACH,qBAJW,UAAU,cACV,OAAO,GACL,uBAAuB,CAWnC;IA5BG;;;OAGG;IACH,WAFU,OAAO,CAEoB;IAErC;;;OAGG;IACH,SAFU,UAAU,CAED;IAwBvB,0DAMC;CACJ;2BA1D0B,qBAAqB;oBAC5B,kCAAkC"}

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

@@ -2,15 +2,14 @@ import { CellFilter } from "../../CellFilter.js";
 import Vector3 from "../../../../core/geom/Vector3.js";
 import { assert } from "../../../../core/assert.js";
 import { v3_angle_between } from "../../../../core/geom/vec3/v3_angle_between.js";
+import { computeFilterSurfaceNormal } from "../process/computeFilterSurfaceNormal.js";
 
-/**
- * Distance from the reference point where support points will be sampled to compute derivative
- * @type {number}
- */
-const DERIVATIVE_OFFSET = 1;
+const normal = [];
 
 /**
- * Builds surface normal of another filter, and then computes the angle to a fixed 3d vector
+ * Builds surface normal of another filter, and then computes the angle to a fixed 3d vector.
+ * Normal convention is that of {@link computeFilterSurfaceNormal}: z is up, a surface rising
+ * along +x has a normal tilting towards -x.
  */
 export class CellFilterAngleToNormal extends CellFilter {
     constructor() {
@@ -46,40 +45,15 @@ export class CellFilterAngleToNormal extends CellFilter {
         return r;
     }
 
-    initialize(grid, seed) {
-        if (!this.surface.initialized) {
-            this.surface.initialize(grid, seed);
-        }
-
-        super.initialize(grid, seed);
+    get children() {
+        return [this.surface];
     }
 
     execute(grid, x, y, rotation) {
-        const filter = this.surface;
-
-        //read surrounding points
-        const top = filter.execute(grid, x, y - DERIVATIVE_OFFSET, 0);
-
-        const left = filter.execute(grid, x - DERIVATIVE_OFFSET, y, 0);
-        const right = filter.execute(grid, x + DERIVATIVE_OFFSET, y, 0);
-
-        const bottom = filter.execute(grid, x, y + DERIVATIVE_OFFSET, 0);
-
-        // compute gradients
-        const dX = (right) - (left);
-        const dY = (bottom) - (top);
-
-        //normalize vector
-        const magnitude = Math.sqrt(dX * dX + dY * dY + 4);
-
-        const _x = dX / magnitude;
-        const _y = dY / magnitude;
-        const _z = 2 / magnitude;
+        computeFilterSurfaceNormal(normal, this.surface, grid, x, y);
 
         const reference = this.reference;
 
-        const angle = v3_angle_between(reference.x, reference.y, reference.z, _x, _y, _z);
-
-        return angle;
+        return v3_angle_between(reference.x, reference.y, reference.z, normal[0], normal[1], normal[2]);
     }
 }

package/src/generation/filtering/numeric/complex/CellFilterCurvature.d.ts

@@ -10,7 +10,6 @@ export class CellFilterCurvature extends CellFilter {
      * @type {CellFilter}
      */
     surface: CellFilter;
-    initialize(grid: any, seed: any): void;
     /**
      *
      * @param grid

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

@@ -1 +1 @@
-{"version":3,"file":"CellFilterCurvature.d.ts","sourceRoot":"","sources":["../../../../../../src/generation/filtering/numeric/complex/CellFilterCurvature.js"],"names":[],"mappings":"AA4DA;IAUI;;;;OAIG;IACH,qBAHW,UAAU,GACT,mBAAmB,CAW9B;IArBG;;;OAGG;IACH,SAFU,UAAU,CAEL;IAmBnB,uCAMC;IAED;;;;;;;OAOG;IACH,mDAFY,MAAM,CAoBjB;CACJ;2BAxH0B,qBAAqB"}
+{"version":3,"file":"CellFilterCurvature.d.ts","sourceRoot":"","sources":["../../../../../../src/generation/filtering/numeric/complex/CellFilterCurvature.js"],"names":[],"mappings":"AAiCA;IAUI;;;;OAIG;IACH,qBAHW,UAAU,GACT,mBAAmB,CAW9B;IArBG;;;OAGG;IACH,SAFU,UAAU,CAEL;IAuBnB;;;;;;;OAOG;IACH,mDAFY,MAAM,CA2BjB;CACJ;2BAhG0B,qBAAqB"}

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

@@ -1,5 +1,6 @@
 import { assert } from "../../../../core/assert.js";
 import { CellFilter } from "../../CellFilter.js";
+import { computeFilterSurfaceNormal } from "../process/computeFilterSurfaceNormal.js";
 
 
 /*
@@ -24,39 +25,11 @@ const xneg = [];
 const xpos = [];
 
 /**
- *
- * @param {GridData} grid
- * @param {number[]} result
- * @param {CellFilter} surface
- * @param {number} x
- * @param {number} y
+ * Guards against re-entrant use of the shared scratch arrays above, which would corrupt an
+ * in-flight computation (e.g. curvature of a filter graph that itself contains a curvature filter)
+ * @type {boolean}
  */
-function computeNormal(grid, result, surface, x, y) {
-
-
-    //read surrounding points
-    const top = surface.execute(grid, x, y - 1, 0);
-
-    const left = surface.execute(grid, x - 1, y, 0);
-    const right = surface.execute(grid, x + 1, y, 0);
-
-    const bottom = surface.execute(grid, x, y + 1, 0);
-
-    // compute gradients
-    const dX = (right) - (left);
-    const dY = (bottom) - (top);
-
-    //normalize vector
-    const magnitude = Math.sqrt(dX * dX + dY * dY + 4);
-
-    const _x = dX / magnitude;
-    const _y = dY / magnitude;
-    const _z = 2 / magnitude;
-
-    result[0] = _x;
-    result[1] = _y;
-    result[2] = _z;
-}
+let scratch_locked = false;
 
 export class CellFilterCurvature extends CellFilter {
 
@@ -84,12 +57,8 @@ export class CellFilterCurvature extends CellFilter {
         return r;
     }
 
-    initialize(grid, seed) {
-        if (!this.surface.initialized) {
-            this.surface.initialize(grid, seed);
-        }
-
-        super.initialize(grid, seed);
+    get children() {
+        return [this.surface];
     }
 
     /**
@@ -104,19 +73,26 @@ export class CellFilterCurvature extends CellFilter {
 
         const surface = this.surface;
 
+        assert.equal(scratch_locked, false, 're-entrant curvature computation, surface filter graph contains another curvature filter');
+
+        scratch_locked = true;
+
         //compute normals up, down, left, right
-        computeNormal(grid, yneg, surface, x, y - 1);
-        computeNormal(grid, xneg, surface, x - 1, y);
-        computeNormal(grid, xpos, surface, x + 1, y);
-        computeNormal(grid, ypos, surface, x, y + 1);
+        computeFilterSurfaceNormal(yneg, surface, grid, x, y - 1);
+        computeFilterSurfaceNormal(xneg, surface, grid, x - 1, y);
+        computeFilterSurfaceNormal(xpos, surface, grid, x + 1, y);
+        computeFilterSurfaceNormal(ypos, surface, grid, x, y + 1);
 
 
-        // compute curvature value
+        // compute curvature value; with the heightfield normal convention a convex
+        // surface (dome) yields positive curvature, a concave one (bowl) negative
         const cross_xneg_xpos_y = xneg[2] * xpos[0] - xneg[0] * xpos[2];
         const cross_yneg_ypos_x = yneg[1] * ypos[2] - yneg[2] * ypos[1];
 
         const curvature = (cross_xneg_xpos_y - cross_yneg_ypos_x);
 
+        scratch_locked = false;
+
         return curvature;
     }
 }

package/src/generation/filtering/numeric/complex/CellFilterFXAA.d.ts

@@ -33,7 +33,6 @@ export class CellFilterFXAA extends CellFilter {
      * @type {number}
      */
     console_edge_sharpness: number;
-    initialize(grid: any, seed: any): void;
     execute(grid: any, x: any, y: any, rotation: any): number;
 }
 import { CellFilter } from "../../CellFilter.js";

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

@@ -1 +1 @@
-{"version":3,"file":"CellFilterFXAA.d.ts","sourceRoot":"","sources":["../../../../../../src/generation/filtering/numeric/complex/CellFilterFXAA.js"],"names":[],"mappings":"AAQA;;GAEG;AACH;IAiCI;;;;OAIG;IACH,oBAHW,UAAU,GACR,cAAc,CAY1B;IA7CD;;;OAGG;IACH,QAFU,UAAU,CAEN;IAEd;;;;OAIG;IACH,gBAFU,MAAM,CAEM;IAEtB;;;;;OAKG;IACH,4BAFU,MAAM,CAEkB;IAElC;;;;;OAKG;IACH,wBAFU,MAAM,CAEW;IAoB3B,uCAMC;IAED,0DAwDC;CACJ;2BAxH0B,qBAAqB"}
+{"version":3,"file":"CellFilterFXAA.d.ts","sourceRoot":"","sources":["../../../../../../src/generation/filtering/numeric/complex/CellFilterFXAA.js"],"names":[],"mappings":"AAQA;;GAEG;AACH;IAiCI;;;;OAIG;IACH,oBAHW,UAAU,GACR,cAAc,CAY1B;IA7CD;;;OAGG;IACH,QAFU,UAAU,CAEN;IAEd;;;;OAIG;IACH,gBAFU,MAAM,CAEM;IAEtB;;;;;OAKG;IACH,4BAFU,MAAM,CAEkB;IAElC;;;;;OAKG;IACH,wBAFU,MAAM,CAEW;IAwB3B,0DAwDC;CACJ;2BApH0B,qBAAqB"}

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

@@ -59,12 +59,8 @@ export class CellFilterFXAA extends CellFilter {
         return r;
     }
 
-    initialize(grid, seed) {
-        super.initialize(grid, seed);
-
-        if (!this.source.initialized) {
-            this.source.initialize(grid, seed);
-        }
+    get children() {
+        return [this.source];
     }
 
     execute(grid, x, y, rotation) {

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

@@ -1 +1 @@
-{"version":3,"file":"CellFilterGaussianBlur.d.ts","sourceRoot":"","sources":["../../../../../../src/generation/filtering/numeric/complex/CellFilterGaussianBlur.js"],"names":[],"mappings":"AAMA;IA+DI;;;;;;;OAOG;IACH,oBANW,UAAU,KACV,MAAM,KACN,MAAM,YACN,MAAM,GACJ,sBAAsB,CAkBlC;IAtFD,kBAAc;IACd,kBAAc;IAEd,gBAAa;IACb,gBAAa;IAEb;;;OAGG;IACH,QAFU,UAAU,CAEN;IAEd,eAAW;IACX,eAAW;IAEX;;;;OAIG;IACH,iBAA+B;IAE/B;;;;OAIG;IACH,wBAAoB;IAEpB;;;;OAIG;IACH,wBAAoB;IAEpB,uCAuBC;IA6BD,0DA4CC;CACJ;2BAxI0B,qBAAqB"}
+{"version":3,"file":"CellFilterGaussianBlur.d.ts","sourceRoot":"","sources":["../../../../../../src/generation/filtering/numeric/complex/CellFilterGaussianBlur.js"],"names":[],"mappings":"AAMA;IA2DI;;;;;;;OAOG;IACH,oBANW,UAAU,KACV,MAAM,KACN,MAAM,YACN,MAAM,GACJ,sBAAsB,CAmBlC;IAnFD,kBAAc;IACd,kBAAc;IAEd,gBAAa;IACb,gBAAa;IAEb;;;OAGG;IACH,QAFU,UAAU,CAEN;IAEd,eAAW;IACX,eAAW;IAEX;;;;OAIG;IACH,iBAA+B;IAE/B;;;;OAIG;IACH,wBAAoB;IAEpB;;;;OAIG;IACH,wBAAoB;IAMpB,uCAeC;IA8BD,0DA4CC;CACJ;2BArI0B,qBAAqB"}

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

@@ -41,14 +41,12 @@ export class CellFilterGaussianBlur extends CellFilter {
      */
     __local_v_scale = 0;
 
-    initialize(grid, seed) {
-        if (this.initialized) {
-            return;
-        }
+    get children() {
+        return [this.source];
+    }
 
-        if (!this.source.initialized) {
-            this.source.initialize(grid, seed);
-        }
+    initialize(grid, seed) {
+        super.initialize(grid, seed);
 
         assert.isNonNegativeInteger(this.samples_x, 'samples_x');
         assert.isNonNegativeInteger(this.samples_y, 'samples_y');
@@ -62,8 +60,6 @@ export class CellFilterGaussianBlur extends CellFilter {
         // precompute scaling for the sampling(execute) stage
         this.__local_u_scale = this.size_x / (this.samples_x - 1);
         this.__local_v_scale = this.size_y / (this.samples_y - 1);
-
-        super.initialize(grid, seed);
     }
 
 
@@ -86,9 +82,10 @@ export class CellFilterGaussianBlur extends CellFilter {
         r.size_x = x;
         r.size_y = y;
 
-        // sigma should scale with radius
-        r.sigma_x = x * 3;
-        r.sigma_y = y * 3;
+        // sigma is in kernel-index units; the kernel spans ±(samples-1)/2 indices
+        // and should cover ±3 sigma of the gaussian
+        r.sigma_x = (r.samples_x - 1) / 6;
+        r.sigma_y = (r.samples_y - 1) / 6;
 
         return r;
     }

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

@@ -1 +1 @@
-{"version":3,"file":"CellFilterSimplexNoise.d.ts","sourceRoot":"","sources":["../../../../../../src/generation/filtering/numeric/complex/CellFilterSimplexNoise.js"],"names":[],"mappings":"AAQA;IA2BI;;;;;;;;OAQG;IACH,wBAPW,MAAM,SACN,MAAM,SAGN,MAAM,gBAFN,MAAM,eACN,MAAM,GAEJ,UAAU,CAyCtB;IAED;;;;;;OAMG;IACH,qBALW,MAAM,WACN,MAAM,SACN,MAAM,GACJ,sBAAsB,CAalC;IA7FG;;;OAGG;IACH,cAAa;IAEb;;;OAGG;IACH,eAAyB;IAEzB,gBAAY;IACZ,gBAAY;IAEZ,oBAAgB;IAChB,oBAAgB;IAEhB;;;;OAIG;IACH,eAAW;IAwEf,uCAMC;IAED,0DAKC;CACJ;2BArH0B,qBAAqB"}
+{"version":3,"file":"CellFilterSimplexNoise.d.ts","sourceRoot":"","sources":["../../../../../../src/generation/filtering/numeric/complex/CellFilterSimplexNoise.js"],"names":[],"mappings":"AAQA;IA2BI;;;;;;;;OAQG;IACH,wBAPW,MAAM,SACN,MAAM,SAGN,MAAM,gBAFN,MAAM,eACN,MAAM,GAEJ,UAAU,CA0CtB;IAED;;;;;;OAMG;IACH,qBALW,MAAM,WACN,MAAM,SACN,MAAM,GACJ,sBAAsB,CAalC;IA9FG;;;OAGG;IACH,cAAa;IAEb;;;OAGG;IACH,eAAyB;IAEzB,gBAAY;IACZ,gBAAY;IAEZ,oBAAgB;IAChB,oBAAgB;IAEhB;;;;OAIG;IACH,eAAW;IAyEf,uCAMC;IAED,0DAKC;CACJ;2BAtH0B,qBAAqB"}

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

@@ -53,7 +53,8 @@ export class CellFilterSimplexNoise extends CellFilter {
         const G = Math.pow(2, -persistence);
 
         for (let i = 0; i < octaves; i++) {
-            const noise = CellFilterSimplexNoise.from(scale * frequency, scale * frequency, s);
+            // scale is a wavelength, successive octaves are higher frequency = shorter wavelength
+            const noise = CellFilterSimplexNoise.from(scale / frequency, scale / frequency, s);
 
             if (r === undefined) {
                 r = noise;

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

@@ -13,7 +13,6 @@ export class CellFilterSobel extends CellFilter {
      * @type {CellFilter}
      */
     source: CellFilter;
-    initialize(grid: any, seed: any): void;
     execute(grid: any, x: any, y: any, rotation: any): number;
 }
 import { CellFilter } from "../../CellFilter.js";

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;IAiBI;;;;OAIG;IACH,oBAHW,UAAU,GACR,eAAe,CAU3B;IA5BD;;;OAGG;IACH,QAFU,UAAU,CAEN;IAEd,uCAMC;IAkBD,0DAuBC;CACJ;2BA9D0B,qBAAqB"}
+{"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"}

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

@@ -12,12 +12,8 @@ export class CellFilterSobel extends CellFilter {
      */
     source = null;
 
-    initialize(grid, seed) {
-        super.initialize(grid, seed);
-
-        if (!this.source.initialized) {
-            this.source.initialize(grid, seed);
-        }
+    get children() {
+        return [this.source];
     }
 
 

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

@@ -1,9 +1,10 @@
 export class CellFilterInverseLerp extends CellFilterOperationTertiary {
     /**
-     *
-     * @param {CellFilter} a
-     * @param {CellFilter} b
-     * @param {CellFilter} f Interpolation factor, expected value between 0 and 1, 0 would lead to filter A being used, and 1 to filter B being used, values between 0 and 1 produce a proportional mix
+     * Computes where `value` sits between `a` and `b`: result is 0 when value equals A, 1 when value equals B,
+     * proportional in between (the inverse of lerp)
+     * @param {CellFilter} a Lower edge
+     * @param {CellFilter} b Upper edge
+     * @param {CellFilter} f Value to be mapped into the [a,b] range
      * @returns {CellFilterInverseLerp}
      */
     static from(a: CellFilter, b: CellFilter, f: CellFilter): CellFilterInverseLerp;

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

@@ -1 +1 @@
-{"version":3,"file":"CellFilterInverseLerp.d.ts","sourceRoot":"","sources":["../../../../../../src/generation/filtering/numeric/math/CellFilterInverseLerp.js"],"names":[],"mappings":"AAIA;IAEI;;;;;;OAMG;IACH,0DAFa,qBAAqB,CAoBjC;IAED,8CAEC;CACJ;4CAnC2C,2CAA2C"}
+{"version":3,"file":"CellFilterInverseLerp.d.ts","sourceRoot":"","sources":["../../../../../../src/generation/filtering/numeric/math/CellFilterInverseLerp.js"],"names":[],"mappings":"AAIA;IAEI;;;;;;;OAOG;IACH,0DAFa,qBAAqB,CAoBjC;IAED,8CAEC;CACJ;4CApC2C,2CAA2C"}

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

@@ -5,10 +5,11 @@ import { assert } from "../../../../core/assert.js";
 export class CellFilterInverseLerp extends CellFilterOperationTertiary {
 
     /**
-     *
-     * @param {CellFilter} a
-     * @param {CellFilter} b
-     * @param {CellFilter} f Interpolation factor, expected value between 0 and 1, 0 would lead to filter A being used, and 1 to filter B being used, values between 0 and 1 produce a proportional mix
+     * Computes where `value` sits between `a` and `b`: result is 0 when value equals A, 1 when value equals B,
+     * proportional in between (the inverse of lerp)
+     * @param {CellFilter} a Lower edge
+     * @param {CellFilter} b Upper edge
+     * @param {CellFilter} f Value to be mapped into the [a,b] range
      * @returns {CellFilterInverseLerp}
      */
     static from(a, b, f) {

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

@@ -0,0 +1,17 @@
+/**
+ * Compute the surface normal of a filter treated as a heightfield over the grid plane.
+ *
+ * Convention: the filter value is height along z, the normal's z component points "up"
+ * (towards increasing height); for a surface rising along +x the normal tilts towards -x.
+ *
+ * NOTE: `result` is only written after all filter sampling is done, so the same scratch
+ * array may safely be threaded through nested filter graphs.
+ *
+ * @param {number[]} result normalized x,y,z
+ * @param {CellFilter} filter
+ * @param {GridData} grid
+ * @param {number} x
+ * @param {number} y
+ */
+export function computeFilterSurfaceNormal(result: number[], filter: CellFilter, grid: GridData, x: number, y: number): void;
+//# sourceMappingURL=computeFilterSurfaceNormal.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"computeFilterSurfaceNormal.d.ts","sourceRoot":"","sources":["../../../../../../src/generation/filtering/numeric/process/computeFilterSurfaceNormal.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;GAcG;AACH,mDANW,MAAM,EAAE,yCAGR,MAAM,KACN,MAAM,QAsBhB"}

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

@@ -0,0 +1,42 @@
+/**
+ * Distance from the reference point where support points are sampled to compute the derivative
+ * @type {number}
+ */
+const DERIVATIVE_OFFSET = 1;
+
+/**
+ * Compute the surface normal of a filter treated as a heightfield over the grid plane.
+ *
+ * Convention: the filter value is height along z, the normal's z component points "up"
+ * (towards increasing height); for a surface rising along +x the normal tilts towards -x.
+ *
+ * NOTE: `result` is only written after all filter sampling is done, so the same scratch
+ * array may safely be threaded through nested filter graphs.
+ *
+ * @param {number[]} result normalized x,y,z
+ * @param {CellFilter} filter
+ * @param {GridData} grid
+ * @param {number} x
+ * @param {number} y
+ */
+export function computeFilterSurfaceNormal(result, filter, grid, x, y) {
+
+    //read surrounding points
+    const top = filter.execute(grid, x, y - DERIVATIVE_OFFSET, 0);
+
+    const left = filter.execute(grid, x - DERIVATIVE_OFFSET, y, 0);
+    const right = filter.execute(grid, x + DERIVATIVE_OFFSET, y, 0);
+
+    const bottom = filter.execute(grid, x, y + DERIVATIVE_OFFSET, 0);
+
+    // central differences over a span of 2 * DERIVATIVE_OFFSET
+    const dX = right - left;
+    const dY = bottom - top;
+
+    // normal of a heightfield is proportional to (-dh/dx, -dh/dy, 1)
+    const magnitude = Math.sqrt(dX * dX + dY * dY + 4);
+
+    result[0] = -dX / magnitude;
+    result[1] = -dY / magnitude;
+    result[2] = 2 / magnitude;
+}

package/src/generation/filtering/numeric/sampling/AbstractCellFilterSampleGridLayer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AbstractCellFilterSampleGridLayer.d.ts","sourceRoot":"","sources":["../../../../../../src/generation/filtering/numeric/sampling/AbstractCellFilterSampleGridLayer.js"],"names":[],"mappings":"AAEA;IAGI;;;OAGG;IACH,SAFU,MAAM,CAED;IAEf;;;;OAIG;IACH,gBAAe;IAEf,kBAAc;IACd,kBAAc;IACd;;;;OAIG;IACH,kBAAiB;IAGjB,uCAUC;CAEJ;2BAxC0B,qBAAqB"}
+{"version":3,"file":"AbstractCellFilterSampleGridLayer.d.ts","sourceRoot":"","sources":["../../../../../../src/generation/filtering/numeric/sampling/AbstractCellFilterSampleGridLayer.js"],"names":[],"mappings":"AAEA;IAGI;;;OAGG;IACH,SAFU,MAAM,CAED;IAEf;;;;OAIG;IACH,gBAAe;IAEf,kBAAc;IACd,kBAAc;IACd;;;;OAIG;IACH,kBAAiB;IAGjB,uCAgBC;CAEJ;2BA9C0B,qBAAqB"}