@woosh/meep-engine 2.37.19 → 2.37.20

package/engine/navigation/ecs/components/computeNonuniformCatmullRomSplineSample.js

@@ -123,3 +123,120 @@ export function computeNonuniformCatmullRomSplineSample(result, p0, p1, p2, p3,
         result[i] = C;
     }
 }
+
+
+/**
+ * Alpha assumed to be 0.5
+ * @param {number} f
+ * @param {number} p0
+ * @param {number} p1
+ * @param {number} p2
+ * @param {number} p3
+ * @returns {number}
+ */
+function catmullrom_1d(f, p0, p1, p2, p3) {
+    const half_alpha = 0.25;
+
+    /**
+     *
+     * @param {number} p0
+     * @param {number} p1
+     * @param {number} half_alpha between 0..0.5
+     * @returns {number}
+     */
+    function getT(p0, p1, half_alpha) {
+        const dx = p0 - p1;
+
+        const a = dx * dx;
+
+        return Math.pow(a, half_alpha);
+    }
+
+    // calculate T
+    const t0 = 0;
+    let t_01 = getT(p0, p1, half_alpha);
+    let t_02 = getT(p1, p2, half_alpha);
+    let t_03 = getT(p2, p3, half_alpha);
+
+    // safety check for repeated points, to prevent division by 0
+    if (t_01 < 1e-5) {
+        t_01 = 1;
+    }
+    if (t_02 < 1e-5) {
+        t_02 = t_01;
+    }
+    if (t_03 < 1e-5) {
+        t_03 = t_02;
+    }
+
+    const t1 = t_01 + t0;
+    const t2 = t_02 + t1;
+    const t3 = t_03 + t2;
+
+    /**
+     * Interpolation between points 1 and 2
+     * @type {number}
+     */
+    const t = t1 * (1 - f) + t2 * f;
+
+    /*
+            Vector2 A1 = (t1-t)/(t1-t0)*p0 + (t-t0)/(t1-t0)*p1;
+		    Vector2 A2 = (t2-t)/(t2-t1)*p1 + (t-t1)/(t2-t1)*p2;
+		    Vector2 A3 = (t3-t)/(t3-t2)*p2 + (t-t2)/(t3-t2)*p3;
+
+		    Vector2 B1 = (t2-t)/(t2-t0)*A1 + (t-t0)/(t2-t0)*A2;
+		    Vector2 B2 = (t3-t)/(t3-t1)*A2 + (t-t1)/(t3-t1)*A3;
+
+		    Vector2 C = (t2-t)/(t2-t1)*B1 + (t-t1)/(t2-t1)*B2;
+     */
+
+    const d_t1_t0 = t1 - t0;
+
+    const m_A1_0 = (t1 - t) / d_t1_t0;
+    const m_A1_1 = (t - t0) / d_t1_t0;
+
+    const d_t2_t1 = t2 - t1;
+
+    const m_A2_0 = (t2 - t) / d_t2_t1;
+
+    const d_t_t1 = t - t1;
+
+    const m_A2_1 = d_t_t1 / d_t2_t1;
+
+    const d_t3_t2 = t3 - t2;
+
+    const d_t3_t = t3 - t;
+
+    const m_A3_0 = d_t3_t / d_t3_t2;
+    const m_A3_1 = (t - t2) / d_t3_t2;
+
+    const d_t2_t0 = t2 - t0;
+
+    const m_B1_0 = (t2 - t) / d_t2_t0;
+    const m_B1_1 = (t - t0) / d_t2_t0;
+
+    const d_t3_t1 = t3 - t1;
+
+    const m_B2_0 = d_t3_t / d_t3_t1;
+    const m_B2_1 = d_t_t1 / d_t3_t1;
+
+    const m_C_0 = (t2 - t) / d_t2_t1;
+    const m_C_1 = d_t_t1 / d_t2_t1;
+
+    // read vector values for the dimension
+    const v0 = p0;
+    const v1 = p1;
+    const v2 = p2;
+    const v3 = p3;
+
+    // compute resulting value in this dimension
+    const A1 = m_A1_0 * v0 + m_A1_1 * v1;
+    const A2 = m_A2_0 * v1 + m_A2_1 * v2;
+    const A3 = m_A3_0 * v2 + m_A3_1 * v3;
+
+    const B1 = m_B1_0 * A1 + m_B1_1 * A2;
+    const B2 = m_B2_0 * A2 + m_B2_1 * A3;
+
+    return m_C_0 * B1 + m_C_1 * B2;
+
+}

package/engine/platform/GetURLHash.js

@@ -0,0 +1,27 @@
+/**
+ * extracts hash parameters
+ * @returns {Object<string>}
+ */
+export function getURLHash() {
+    const result = {};
+
+    if (window === undefined) {
+        return result;
+    }
+
+    const location = window.location;
+
+    const hash = location.hash;
+
+    const hashRegEx = /([a-zA-Z0-9\-\_]+)\=([a-zA-Z0-9\-\_]+)/g;
+
+    let match;
+    while ((match = hashRegEx.exec(hash)) !== null) {
+        const variableName = match[1];
+        const value = match[2];
+
+        result[variableName] = value;
+    }
+
+    return result;
+}

package/engine/platform/WebEnginePlatform.js

@@ -2,6 +2,7 @@ import { EnginePlatform } from "./EnginePlatform.js";
 import { IndexedDBStorage } from "../save/storage/IndexedDBStorage.js";
 import { StorageAchievementGateway } from "../achievements/gateway/StorageAchievementGateway.js";
 import { arrayPickBestElement } from "../../core/collection/array/arrayPickBestElement.js";
+import { getURLHash } from "./GetURLHash.js";
 
 export class WebEnginePlatform extends EnginePlatform {
     constructor({
@@ -32,29 +33,7 @@ export class WebEnginePlatform extends EnginePlatform {
     }
 
     pickDefaultLocale(localeOptions) {
-        function getURLHash() {
-            const result = {};
 
-            if (window === undefined) {
-                return result;
-            }
-
-            const location = window.location;
-
-            const hash = location.hash;
-
-            const hashRegEx = /([a-zA-Z0-9\-\_]+)\=([a-zA-Z0-9\-\_]+)/g;
-
-            let match;
-            while ((match = hashRegEx.exec(hash)) !== null) {
-                const variableName = match[1];
-                const value = match[2];
-
-                result[variableName] = value;
-            }
-
-            return result;
-        }
 
         function pickLanguageByNavigator() {
             /**

package/engine/sound/ecs/emitter/SoundEmitter.js

@@ -8,10 +8,14 @@ import Vector1 from "../../../../core/geom/Vector1.js";
 import { SoundTrack } from "./SoundTrack.js";
 import { SoundEmitterFlags } from "./SoundEmitterFlags.js";
 import { SoundAttenuationFunction } from "./SoundAttenuationFunction.js";
-import { attenuateSoundLinear } from "./attenuate/attenuateSoundLinear.js";
-import { attenuateSoundLogarithmic } from "./attenuate/attenuateSoundLogarithmic.js";
+import {
+    interpolate_irradiance_linear
+} from "../../../../core/math/physics/irradiance/interpolate_irradiance_linear.js";
+import {
+    interpolate_irradiance_lograrithmic
+} from "../../../../core/math/physics/irradiance/interpolate_irradiance_lograrithmic.js";
 import { SoundPanningModelType } from "./SoundPanningModelType.js";
-import { attenuateSoundSmith } from "./attenuate/attenuateSoundSmith.js";
+import { interpolate_irradiance_smith } from "../../../../core/math/physics/irradiance/interpolate_irradiance_smith.js";
 import { objectKeyByValue } from "../../../../core/model/object/objectKeyByValue.js";
 import { computeStringHash } from "../../../../core/primitives/strings/computeStringHash.js";
 import { computeHashIntegerArray } from "../../../../core/collection/array/computeHashIntegerArray.js";
@@ -354,11 +358,11 @@ export class SoundEmitter {
         const distance_max = this.__distanceMax;
 
         if (attenuation === SoundAttenuationFunction.Linear) {
-            volume = attenuateSoundLinear(distance, distance_min, distance_max);
+            volume = interpolate_irradiance_linear(distance, distance_min, distance_max);
         } else if (attenuation === SoundAttenuationFunction.Logarithmic) {
-            volume = attenuateSoundLogarithmic(distance, distance_min, distance_max);
+            volume = interpolate_irradiance_lograrithmic(distance, distance_min, distance_max);
         } else if (attenuation === SoundAttenuationFunction.Smith) {
-            volume = attenuateSoundSmith(distance, distance_min, distance_max);
+            volume = interpolate_irradiance_smith(distance, distance_min, distance_max);
         } else {
             //unsupported function, don't attenuate
             volume = 1;

package/generation/GridGenerator.js

@@ -34,11 +34,12 @@ export class GridGenerator {
          */
         const tasks = [];
 
-        const n = this.generators.length;
+        const generators = this.generators;
+        const generator_count = generators.length;
 
         //generate tasks
-        for (let i = 0; i < n; i++) {
-            const generator = this.generators[i];
+        for (let i = 0; i < generator_count; i++) {
+            const generator = generators[i];
 
             const task = generator.build(grid, ecd, seed);
 
@@ -46,8 +47,8 @@ export class GridGenerator {
         }
 
         //assign dependencies
-        for (let i = 0; i < n; i++) {
-            const generator = this.generators[i];
+        for (let i = 0; i < generator_count; i++) {
+            const generator = generators[i];
 
             const task = tasks[i];
 
@@ -59,7 +60,7 @@ export class GridGenerator {
 
                 const dependency = dependencies[j];
 
-                const dependencyIndex = this.generators.indexOf(dependency);
+                const dependencyIndex = generators.indexOf(dependency);
 
                 if (dependencyIndex === -1) {
                     throw new Error(`Dependency ${j}(name='${dependency.name}') of task generator [${i}] (name='${generator.name}') is not found`);

package/generation/example/SampleGenerator0.js

@@ -34,7 +34,7 @@ import { CellMatcherAny } from "../rules/CellMatcherAny.js";
 import { CellFilterGaussianBlur } from "../filtering/numeric/complex/CellFilterGaussianBlur.js";
 import { GridCellActionSequence } from "../placement/action/util/GridCellActionSequence.js";
 import { CellFilterStep } from "../filtering/numeric/math/CellFilterStep.js";
-import { CellFilterReadGridLayer } from "../filtering/numeric/CellFilterReadGridLayer.js";
+import { CellFilterSampleLayerLinear } from "../filtering/numeric/sampling/CellFilterSampleLayerLinear.js";
 import { CellFilterAngleToNormal } from "../filtering/numeric/complex/CellFilterAngleToNormal.js";
 import Vector3 from "../../core/geom/Vector3.js";
 import { CellFilterOneMinus } from "../filtering/numeric/math/CellFilterOneMinus.js";
@@ -138,7 +138,7 @@ const ACTION_PLACE_ENEMY_MARKER = GridCellActionPlaceMarker.from({
                             CellFilterSubtract.from(
                                 CellFilterMultiply.from(
                                     CellFilterDivide.from(
-                                        CellFilterReadGridLayer.from(MirGridLayers.DistanceFromStart),
+                                        CellFilterSampleLayerLinear.from(MirGridLayers.DistanceFromStart),
                                         //increase level by 1 for each X tiles distance
                                         CellFilterLiteralFloat.from(20)
                                     ),
@@ -147,7 +147,7 @@ const ACTION_PLACE_ENEMY_MARKER = GridCellActionPlaceMarker.from({
                                         CellFilterSmoothStep.from(
                                             CellFilterLiteralFloat.from(20),
                                             CellFilterLiteralFloat.from(50),
-                                            CellFilterReadGridLayer.from(MirGridLayers.DistanceFromStart)
+                                            CellFilterSampleLayerLinear.from(MirGridLayers.DistanceFromStart)
                                         ),
                                         CellFilterLerp.from(
                                             CellFilterLiteralFloat.from(0.9),
@@ -277,7 +277,7 @@ const gDrawLayerMoisture = GridTaskActionRuleSet.from({
 });
 
 //trees
-const fReadHeight = CellFilterReadGridLayer.from(MirGridLayers.Heights);
+const fReadHeight = CellFilterSampleLayerLinear.from(MirGridLayers.Heights);
 
 const fTreeArea = CellFilterCache.from(
     CellFilterMultiply.from(
@@ -287,7 +287,7 @@ const fTreeArea = CellFilterCache.from(
                 CellFilterInverseLerp.from(
                     CellFilterLiteralFloat.from(0.1),
                     CellFilterLiteralFloat.from(0.5),
-                    CellFilterReadGridLayer.from(MirGridLayers.Moisture)
+                    CellFilterSampleLayerLinear.from(MirGridLayers.Moisture)
                 ),
                 CellFilterLiteralFloat.from(0),
                 CellFilterLiteralFloat.from(1)
@@ -408,7 +408,7 @@ const fSharpSlope = CellFilterCache.from(
         CellFilterLiteralFloat.from(Math.PI / 5),
         CellFilterLiteralFloat.from(Math.PI / 3.5),
         CellFilterAngleToNormal.from(
-            CellFilterReadGridLayer.from(MirGridLayers.Heights),
+            CellFilterSampleLayerLinear.from(MirGridLayers.Heights),
             Vector3.forward
         )
     )

package/generation/example/filters/SampleGroundMoistureFilter.js

@@ -1,32 +1,73 @@
-import { CellFilterAdd } from "../../filtering/numeric/math/algebra/CellFilterAdd.js";
 import { CellFilterMultiply } from "../../filtering/numeric/math/algebra/CellFilterMultiply.js";
 import { CellFilterSimplexNoise } from "../../filtering/numeric/complex/CellFilterSimplexNoise.js";
 import { CellFilterLiteralFloat } from "../../filtering/numeric/CellFilterLiteralFloat.js";
 import { CellFilterGaussianBlur } from "../../filtering/numeric/complex/CellFilterGaussianBlur.js";
-import { CellFilterOneMinus } from "../../filtering/numeric/math/CellFilterOneMinus.js";
 import { CellFilterStep } from "../../filtering/numeric/math/CellFilterStep.js";
-import { CellFilterReadGridLayer } from "../../filtering/numeric/CellFilterReadGridLayer.js";
+import { CellFilterSampleLayerLinear } from "../../filtering/numeric/sampling/CellFilterSampleLayerLinear.js";
 import { MirGridLayers } from "../grid/MirGridLayers.js";
+import { CellFilterMax2 } from "../../filtering/numeric/math/CellFilterMax2.js";
+import { CellFilterSmoothStep } from "../../filtering/numeric/math/CellFilterSmoothStep.js";
+import { MohGridLayers } from "../../../../../generator/MohGridLayers.js";
+import { CellFilterDilate } from "../../filtering/numeric/complex/CellFilterDilate.js";
+import { DEG2RAD } from "three/src/math/MathUtils.js";
+import { CellFilterCache } from "../../filtering/numeric/CellFilterCache.js";
 
-const fReadHeight = CellFilterReadGridLayer.from(MirGridLayers.Heights);
+const fReadHeight = CellFilterSampleLayerLinear.from(MirGridLayers.Heights);
 
-export const SampleGroundMoistureFilter = CellFilterAdd.from(
+const WATER_MASK = CellFilterStep.from(fReadHeight, CellFilterLiteralFloat.from(-0.05));
+const CURVATURE = CellFilterSampleLayerLinear.from(MohGridLayers.Curvature);
+const SLOPE = CellFilterSampleLayerLinear.from(MohGridLayers.Slope);
+
+
+export const SampleGroundMoistureFilter = CellFilterMax2.from(
     // add regional variation in relative moisture
     CellFilterMultiply.from(
-        CellFilterSimplexNoise.from(100, 100),
-        CellFilterLiteralFloat.from(0.4)
+        CellFilterMultiply.from(
+            CellFilterSimplexNoise.fractal(2, 100, 1263),
+            CellFilterMax2.from(
+                // flat areas are more likely to be keep moisture
+                CellFilterSmoothStep.from(
+                    CellFilterLiteralFloat.from(40 * DEG2RAD),
+                    CellFilterLiteralFloat.from(10 * DEG2RAD),
+                    SLOPE
+                ),
+                // water accumulates in crevices
+                CellFilterSmoothStep.from(
+                    CellFilterLiteralFloat.from(0.0),
+                    CellFilterLiteralFloat.from(0.1),
+                    CURVATURE
+                )
+            )
+        ),
+
+        CellFilterLiteralFloat.from(0.5)
     ),
 
-    //simulate water distribution from lakes/rivers/sees into the nearby ground
-    CellFilterMultiply.from(
-        CellFilterGaussianBlur.from(
-            CellFilterOneMinus.from(
-                CellFilterStep.from(CellFilterLiteralFloat.from(0), fReadHeight)
-            ),
-            7,
-            7,
-            1
+    //simulate water diffusion from lakes/rivers/sees into the nearby ground
+    CellFilterGaussianBlur.from(
+        CellFilterCache.from(
+            CellFilterMax2.from(
+                WATER_MASK,
+                CellFilterMultiply.from(
+                    CellFilterGaussianBlur.from(
+                        CellFilterCache.from(CellFilterDilate.from(WATER_MASK)),
+                        5,
+                        5,
+                        1
+                    ),
+                    /*
+                     Diffuse more along surfaces with low slope (flat)
+                     NOTE: we don't have to worry about directly of the slope, as water always starts at 0, so any slope will be positive in effect
+                     */
+                    CellFilterSmoothStep.from(
+                        CellFilterLiteralFloat.from(35 * DEG2RAD),
+                        CellFilterLiteralFloat.from(10 * DEG2RAD),
+                        SLOPE
+                    ),
+                )
+            )
         ),
-        CellFilterLiteralFloat.from(0.6)
+        3, 3, 1
     )
 );
+

package/generation/example/themes/SampleTheme0.js

@@ -21,13 +21,17 @@ import Tag from "../../../engine/ecs/components/Tag.js";
 import HeadsUpDisplay from "../../../engine/ecs/gui/hud/HeadsUpDisplay.js";
 import ViewportPosition from "../../../engine/ecs/gui/position/ViewportPosition.js";
 import GUIElement from "../../../engine/ecs/gui/GUIElement.js";
-import { MarkerNodeTransformerYRotateByFilterGradient } from "../../markers/transform/MarkerNodeTransformerYRotateByFilterGradient.js";
+import {
+    MarkerNodeTransformerYRotateByFilterGradient
+} from "../../markers/transform/MarkerNodeTransformerYRotateByFilterGradient.js";
 import { PI_HALF } from "../../../core/math/MathUtils.js";
 import { CellFilterGaussianBlur } from "../../filtering/numeric/complex/CellFilterGaussianBlur.js";
 import { CellProcessingRule } from "../../theme/cell/CellProcessingRule.js";
-import { ContinuousGridCellActionSetTerrainHeight } from "../../grid/actions/ContinuousGridCellActionSetTerrainHeight.js";
+import {
+    ContinuousGridCellActionSetTerrainHeight
+} from "../../grid/actions/ContinuousGridCellActionSetTerrainHeight.js";
 import { MirGridLayers } from "../grid/MirGridLayers.js";
-import { CellFilterReadGridLayer } from "../../filtering/numeric/CellFilterReadGridLayer.js";
+import { CellFilterSampleLayerLinear } from "../../filtering/numeric/sampling/CellFilterSampleLayerLinear.js";
 import ClingToTerrain from "../../../engine/ecs/terrain/ecs/ClingToTerrain.js";
 import { MarkerNodeTransformerYRotateByFilter } from "../../markers/transform/MarkerNodeTransformerYRotateByFilter.js";
 import { CellFilterAngleToNormal } from "../../filtering/numeric/complex/CellFilterAngleToNormal.js";
@@ -55,14 +59,14 @@ const terrainTheme = new TerrainTheme();
 
 const matcher_tag_road = CellMatcherLayerBitMaskTest.from(GridTags.Road, MirGridLayers.Tags);
 
-const filterMoisture = CellFilterReadGridLayer.from(MirGridLayers.Moisture);
+const filterMoisture = CellFilterSampleLayerLinear.from(MirGridLayers.Moisture);
 
 const filterRock = CellFilterClamp.from(
     CellFilterSmoothStep.from(
         CellFilterLiteralFloat.from(Math.PI / 5),
         CellFilterLiteralFloat.from(Math.PI / 3.5),
         CellFilterAngleToNormal.from(
-            CellFilterReadGridLayer.from(MirGridLayers.Heights),
+            CellFilterSampleLayerLinear.from(MirGridLayers.Heights),
             Vector3.forward
         )
     ),
@@ -101,7 +105,7 @@ const filterSand = CellFilterMultiply.from(
                     CellFilterLiteralFloat.from(0),
                     CellFilterLiteralFloat.from(0.2),
                     CellFilterNegate.from(
-                        CellFilterReadGridLayer.from(MirGridLayers.Heights)
+                        CellFilterSampleLayerLinear.from(MirGridLayers.Heights)
                     )
                 ),
                 3,
@@ -1562,7 +1566,7 @@ SampleTheme0.nodes.add(MarkerProcessingRule.from({
 
 const aHeight = new ContinuousGridCellActionSetTerrainHeight();
 
-aHeight.target = CellFilterReadGridLayer.from(MirGridLayers.Heights);
+aHeight.target = CellFilterSampleLayerLinear.from(MirGridLayers.Heights);
 
 SampleTheme0.cells.add(CellProcessingRule.from(
     CellFilterLiteralFloat.from(1),

package/generation/filtering/numeric/CellFilterLiteralFloat.js

@@ -37,3 +37,8 @@ export class CellFilterLiteralFloat extends CellFilter {
  * @type {CellFilterLiteralFloat}
  */
 CellFilterLiteralFloat.ONE = CellFilterLiteralFloat.from(1);
+/**
+ * @readonly
+ * @type {CellFilterLiteralFloat}
+ */
+CellFilterLiteralFloat.ZERO = CellFilterLiteralFloat.from(0);

package/generation/filtering/numeric/complex/CellFilterDilate.js

@@ -0,0 +1,36 @@
+import { CellFilter } from "../../CellFilter.js";
+import { max2 } from "../../../../core/math/max2.js";
+import { CellFilterUnaryOperation } from "../../core/CellFilterUnaryOperation.js";
+import { assert } from "../../../../core/assert.js";
+
+export class CellFilterDilate extends CellFilterUnaryOperation {
+    /**
+     *
+     * @param {CellFilter} source
+     * @returns {CellFilterDilate}
+     */
+    static from(source) {
+        const r = new CellFilterDilate();
+        assert.equal(source.isCellFilter, true, 'source.isCellFilter !== true');
+
+        r.source = source;
+
+        return r;
+    }
+
+    execute(grid, x, y, rotation) {
+        const filter = this.source;
+
+        let result = Number.NEGATIVE_INFINITY;
+
+        for (let _y = -1; _y <= 1; _y++) {
+            for (let _x = -1; _x <= 1; _x++) {
+                const v = filter.execute(grid, x + _x, y + _y, 0);
+
+                result = max2(result, v);
+            }
+        }
+
+        return result;
+    }
+}

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

@@ -81,14 +81,20 @@ export class CellFilterGaussianBlur extends CellFilter {
     }
 
     initialize(grid, seed) {
+        if (this.initialized) {
+            return;
+        }
+
         if (!this.source.initialized) {
             this.source.initialize(grid, seed);
+        }
 
-            this.__kernel = new Float32Array(this.samples_x * this.samples_y);
+        this.__kernel = new Float32Array(this.samples_x * this.samples_y);
 
-            // initialize kernel
-            this.__kernel_total_power = buildKernel(this.__kernel, this.samples_x, this.samples_y, this.sigma_x, this.sigma_y);
-        }
+        // initialize kernel
+        this.__kernel_total_power = buildKernel(this.__kernel, this.samples_x, this.samples_y, this.sigma_x, this.sigma_y);
+
+        super.initialize(grid, seed);
     }
 
 
@@ -115,6 +121,8 @@ export class CellFilterGaussianBlur extends CellFilter {
     }
 
     execute(grid, x, y, rotation) {
+        assert.ok(this.__initialized, 'not initialized');
+
         const samplesX = this.samples_x;
         const samplesY = this.samples_y;
 
@@ -156,7 +164,9 @@ export class CellFilterGaussianBlur extends CellFilter {
 
                 const sourceValue = source.execute(grid, x + offset_x, y + offset_y, 0);
 
-                sum += sourceValue * power;
+                const sample_contribution = sourceValue * power;
+
+                sum += sample_contribution;
 
             }
         }

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

@@ -1,6 +1,10 @@
 import { seededRandom } from "../../../../core/math/random/seededRandom.js";
 import { CellFilter } from "../../CellFilter.js";
 import SimplexNoise from "simplex-noise";
+import { CellFilterAdd } from "../math/algebra/CellFilterAdd.js";
+import { CellFilterMultiply } from "../math/algebra/CellFilterMultiply.js";
+import { CellFilterLiteralFloat } from "../CellFilterLiteralFloat.js";
+import { CellFilterDivide } from "../math/algebra/CellFilterDivide.js";
 
 export class CellFilterSimplexNoise extends CellFilter {
     constructor() {
@@ -14,7 +18,7 @@ export class CellFilterSimplexNoise extends CellFilter {
 
         /**
          * @private
-         * @type {Function}
+         * @type {function}
          */
         this.random = seededRandom(0);
 
@@ -29,6 +33,54 @@ export class CellFilterSimplexNoise extends CellFilter {
         this.__seed = 0;
     }
 
+    /**
+     * Build a fractal noise filter with a given number of octaves
+     * @param {number} octaves
+     * @param {number} scale
+     * @param {number} persistence
+     * @param {number} lacunarity
+     * @param {number} seed
+     * @returns {CellFilter}
+     */
+    static fractal(octaves, scale, seed = 0, persistence = 0.5, lacunarity = 2) {
+        let s = seed;
+        let r;
+
+        let frequency = 1;
+        let amplitude = 1;
+        let totalAmplitude = 0;
+
+        for (let i = 0; i < octaves; i++) {
+            const noise = CellFilterSimplexNoise.from(scale * frequency, scale * frequency, s);
+
+            if (r === undefined) {
+                r = noise;
+            } else {
+                r = CellFilterAdd.from(
+                    CellFilterMultiply.from(noise, CellFilterLiteralFloat.from(amplitude)),
+                    r
+                );
+            }
+
+            totalAmplitude += amplitude;
+            amplitude *= persistence;
+            frequency *= lacunarity;
+
+            s = (s + 1) * 31;
+        }
+
+        if (totalAmplitude === 1) {
+            return r;
+        } else {
+
+            return CellFilterDivide.from(
+                r,
+                CellFilterLiteralFloat.from(totalAmplitude)
+            );
+
+        }
+    }
+
     /**
      *
      * @param {number} scale_x

package/generation/filtering/numeric/math/CellFilterMax2.js

@@ -24,6 +24,9 @@ export class CellFilterMax2 extends CellFilterBinaryOperation {
     }
 
     operation(left, right) {
+        assert.notNaN(left,'left');
+        assert.notNaN(right,'right');
+
         return max2(left, right);
     }
 }