@woosh/meep-engine 2.37.18 → 2.38.0

package/engine/grid/components/GridObstacle.js

@@ -5,7 +5,6 @@
 
 import Vector2 from '../../../core/geom/Vector2.js';
 import { assert } from "../../../core/assert.js";
-import { BinaryClassSerializationAdapter } from "../../ecs/storage/binary/BinaryClassSerializationAdapter.js";
 import { computeIntegerArrayHash } from "../../../core/primitives/array/computeIntegerArrayHash.js";
 import { isArrayEqualStrict } from "../../../core/collection/array/isArrayEqualStrict.js";
 import { computeHashIntegerArray } from "../../../core/collection/array/computeHashIntegerArray.js";
@@ -245,46 +244,3 @@ GridObstacle.typeName = "GridObstacle";
 
 export default GridObstacle;
 
-export class GridObstacleSerializationAdapter extends BinaryClassSerializationAdapter {
-    constructor() {
-        super();
-
-        this.klass = GridObstacle;
-        this.version = 0;
-    }
-
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     * @param {GridObstacle} value
-     */
-    serialize(buffer, value) {
-
-        const w = value.size.x;
-        const h = value.size.y;
-
-        buffer.writeUint16(w);
-        buffer.writeUint16(h);
-
-        buffer.writeBytes(value.data, 0, w * h);
-    }
-
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     * @param {GridObstacle} value
-     */
-    deserialize(buffer, value) {
-
-        const x = buffer.readUint16();
-        const y = buffer.readUint16();
-
-        value.size.set(x, y);
-
-        const length = x * y;
-
-        value.data = new Uint8Array(length);
-
-        buffer.readBytes(value.data, 0, length);
-    }
-}

package/engine/grid/components/GridObstacleSerializationAdapter.js

@@ -0,0 +1,46 @@
+import { BinaryClassSerializationAdapter } from "../../ecs/storage/binary/BinaryClassSerializationAdapter.js";
+import GridObstacle from "./GridObstacle.js";
+
+export class GridObstacleSerializationAdapter extends BinaryClassSerializationAdapter {
+    constructor() {
+        super();
+
+        this.klass = GridObstacle;
+        this.version = 0;
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {GridObstacle} value
+     */
+    serialize(buffer, value) {
+
+        const w = value.size.x;
+        const h = value.size.y;
+
+        buffer.writeUint16(w);
+        buffer.writeUint16(h);
+
+        buffer.writeBytes(value.data, 0, w * h);
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {GridObstacle} value
+     */
+    deserialize(buffer, value) {
+
+        const x = buffer.readUint16();
+        const y = buffer.readUint16();
+
+        value.size.set(x, y);
+
+        const length = x * y;
+
+        value.data = new Uint8Array(length);
+
+        buffer.readBytes(value.data, 0, length);
+    }
+}

package/engine/input/devices/PointerDevice.d.ts

@@ -12,7 +12,7 @@ export class PointerDevice {
     public readonly on: {
         down: Signal<Vector2, MouseEvent | TouchEvent>,
         up: Signal<Vector2, MouseEvent | TouchEvent>,
-        move: Signal<Vector2, MouseEvent | TouchEvent>,
+        move: Signal<Vector2 /*position*/, MouseEvent | TouchEvent, Vector2 /*delta*/>,
         tap: Signal<Vector2, MouseEvent | TouchEvent>,
         drag: Signal<Vector2, Vector2, Vector2, MouseEvent | TouchEvent>,
         dragStart: Signal<Vector2, MouseEvent | TouchEvent>,

package/engine/input/devices/PointerDevice.js

@@ -350,6 +350,10 @@ function PointerDevice(domElement) {
 
     const position = this.position = new Vector2();
 
+    /**
+     *
+     * @param {MouseEvent} event
+     */
     this.eventHandlerMouseMove = (event) => {
         event.preventDefault();
 
@@ -357,7 +361,7 @@ function PointerDevice(domElement) {
 
         this.readPointerPositionFromEvent(position, event);
 
-        this.on.move.send2(position, event);
+        this.on.move.send3(position, event, new Vector2(event.movementX, event.movementY));
     };
     this.eventHandlerMouseUp = (event) => {
         this.readPointerPositionFromEvent(position, event);
@@ -383,9 +387,13 @@ function PointerDevice(domElement) {
         this.on.move.send3(param0, param1, param2);
     });
 
+    const anchor_touch_last = new Vector2();
+
     this.eventHandlerTouchStart = function (event) {
         getTouchCenter(event.touches, position);
         touchStart.send2(position, event);
+
+        anchor_touch_last.copy(position);
     };
 
     this.eventHandlerTouchEnd = function (event) {
@@ -397,7 +405,14 @@ function PointerDevice(domElement) {
         event.preventDefault();
 
         getTouchCenter(event.touches, position);
-        touchMove.send2(position, event);
+
+        const delta = new Vector2();
+
+        delta.subVectors(position, anchor_touch_last);
+
+        touchMove.send3(position, event, delta);
+
+        anchor_touch_last.copy(position);
     };
 
     const globalUp = new Signal();

package/engine/input/ecs/util/TerrainCameraTargetSampler.js

@@ -1,5 +1,5 @@
 import { Sampler2D } from "../../../graphics/texture/sampler/Sampler2D.js";
-import { downsampleSampler2D } from "../../../graphics/texture/sampler/downsampleSampler2D.js";
+import { sampler2D_scale_down_linear } from "../../../graphics/texture/sampler/sampler2D_scale_down_linear.js";
 import { computeWholeDivisorLow } from "../../../../core/math/MathUtils.js";
 
 /**
@@ -20,7 +20,7 @@ export function buildCameraTargetSampler({ heightSampler }) {
 
     const result = Sampler2D.float32(1, s(heightSampler.width), s(heightSampler.height));
 
-    downsampleSampler2D(heightSampler, result);
+    sampler2D_scale_down_linear(heightSampler, result);
 
     return result;
 }

package/engine/navigation/ecs/components/Path.d.ts

@@ -10,6 +10,8 @@ export default class Path {
 
     public isEmpty(): boolean
 
+    public reverse(): void
+
     public clear(): void
 
     /**

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

@@ -17,7 +17,9 @@ import { min2 } from "../../../../core/math/min2.js";
 import { computeNonuniformCatmullRomSplineSample } from "./computeNonuniformCatmullRomSplineSample.js";
 import { InterpolationType } from "./InterpolationType.js";
 import { v3_distance } from "../../../../core/geom/v3_distance.js";
-import { line3_computeSegmentPointDistance_sqr } from "../../../../core/geom/3d/line/line3_computeSegmentPointDistance_sqr.js";
+import {
+    line3_computeSegmentPointDistance_sqr
+} from "../../../../core/geom/3d/line/line3_computeSegmentPointDistance_sqr.js";
 
 const v3_a = new Vector3();
 const v3_b = new Vector3();
@@ -262,6 +264,9 @@ class Path {
         }
     }
 
+    reverse() {
+        this.__data.reverse_rows();
+    }
 
     /**
      *

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/navigation/grid/AStar.js

@@ -1,4 +1,4 @@
-import BinaryHeap from './FastBinaryHeap.js';
+import BinaryHeap from '../../../core/collection/heap/FastBinaryHeap.js';
 import Vector2 from '../../../core/geom/Vector2.js';
 import { assert } from "../../../core/assert.js";
 

package/engine/navigation/grid/GridField.js

@@ -1,13 +1,14 @@
 import Vector2 from '../../../core/geom/Vector2.js';
 import { clamp } from "../../../core/math/clamp.js";
-import BinaryHeap from './BinaryHeap.js';
+import BinaryHeap from '../../../core/collection/heap/BinaryHeap.js';
 import { assert } from "../../../core/assert.js";
 import { gridAStarSearch } from "./AStar.js";
 
 const blockValue = 255;
 
 /**
- *
+ * A kind of 2D data texture
+ * @deprecated prefer using {@link Sampler2D} instead, as it's more versatile and has wider feature set
  * @param {Number} width
  * @param {Number} height
  * @constructor

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/engine/ui/DraggableAspect.js

@@ -60,8 +60,8 @@ export class DraggableAspect {
             pointerGlobal.on.up.add(stopDrag);
         });
 
-        this.pointerGlobal.on.move.add((position) => {
-            drag(position, dragOriginalPosition);
+        this.pointerGlobal.on.move.add((position, event, delta) => {
+            drag(position, dragOriginalPosition, delta);
         });
     }
 

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";
@@ -77,10 +77,12 @@ pNoTreasureIn3.addRule(0, 0, CellMatcherNot.from(CellMatcherContainsMarkerWithin
 )));
 
 const chestPlacementRule = GridCellPlacementRule.from({
-    matcher: CellMatcherAnd.from(pTreasureCorner, pNoTreasureIn3), actions: [
+    matcher: CellMatcherAnd.from(pTreasureCorner, pNoTreasureIn3),
+    action: GridCellActionSequence.from([
         GridCellActionPlaceMarker.from({ type: 'Treasure', size: 0.5 }),
         GridCellActionPlaceTags.from(GridTags.Treasure, MirGridLayers.Tags)
-    ], probability: CellFilterLiteralFloat.from(0.5)
+    ]),
+    probability: CellFilterLiteralFloat.from(0.5)
 });
 
 
@@ -136,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)
                                     ),
@@ -145,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),
@@ -177,10 +179,11 @@ const ACTION_PLACE_ENEMY_TAG = GridCellActionPlaceTags.from(GridTags.Enemy | Gri
 
 const prTreasureGuards = GridCellPlacementRule.from(
     {
-        matcher: pNearTreasure, actions: [
+        matcher: pNearTreasure,
+        action: GridCellActionSequence.from([
             ACTION_PLACE_ENEMY_MARKER,
             ACTION_PLACE_ENEMY_TAG
-        ]
+        ])
     }
 );
 
@@ -194,10 +197,11 @@ const prEnemyTreasureGuard = GridCellPlacementRule.from(
         matcher: CellMatcherAnd.from(
             pNearTreasure,
             pNoEnemyIn3
-        ), actions: [
+        ),
+        action: GridCellActionSequence.from([
             ACTION_PLACE_ENEMY_MARKER,
             ACTION_PLACE_ENEMY_TAG
-        ]
+        ])
     }
 );
 
@@ -207,10 +211,11 @@ const prEnemyCorridorGuard = GridCellPlacementRule.from(
         matcher: CellMatcherAnd.from(
             mir_matcher_attack_corridor,
             pNoEnemyIn3
-        ), actions: [
+        ),
+        action: GridCellActionSequence.from([
             ACTION_PLACE_ENEMY_MARKER,
             ACTION_PLACE_ENEMY_TAG
-        ],
+        ]),
         probability: CellFilterLiteralFloat.from(0.5)
     }
 );
@@ -264,7 +269,7 @@ const gDrawLayerMoisture = GridTaskActionRuleSet.from({
             GridCellPlacementRule.from(
                 {
                     matcher: CellMatcherAny.INSTANCE,
-                    actions: [GridCellActionWriteFilterToLayer.from(MirGridLayers.Moisture, SampleGroundMoistureFilter)]
+                    action: GridCellActionWriteFilterToLayer.from(MirGridLayers.Moisture, SampleGroundMoistureFilter)
                 }
             )
         ]
@@ -272,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(
@@ -282,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)
@@ -403,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
         )
     )
@@ -494,32 +499,31 @@ const gHeights = GridTaskActionRuleSet.from({
             rules: [
                 GridCellPlacementRule.from(
                     {
-                        matcher: CellMatcherAny.INSTANCE, actions: [
-                            GridCellActionWriteFilterToLayer.from(
-                                MirGridLayers.Heights,
+                        matcher: CellMatcherAny.INSTANCE,
+                        actions: GridCellActionWriteFilterToLayer.from(
+                            MirGridLayers.Heights,
 
+                            CellFilterLerp.from(
+                                CellFilterLiteralFloat.from(0),
                                 CellFilterLerp.from(
-                                    CellFilterLiteralFloat.from(0),
-                                    CellFilterLerp.from(
-                                        CellFilterLiteralFloat.from(-2),
-                                        CellFilterLiteralFloat.from(7),
-                                        CellFilterMultiply.from(
-                                            CellFilterSimplexNoise.from(30, 30),
-                                            CellFilterSimplexNoise.from(13, 13)
+                                    CellFilterLiteralFloat.from(-2),
+                                    CellFilterLiteralFloat.from(7),
+                                    CellFilterMultiply.from(
+                                        CellFilterSimplexNoise.from(30, 30),
+                                        CellFilterSimplexNoise.from(13, 13)
+                                    )
+                                ),
+                                CellFilterGaussianBlur.from(
+                                    CellFilterCache.from(
+                                        CellFilterCellMatcher.from(
+                                            mHeightArea
                                         )
                                     ),
-                                    CellFilterGaussianBlur.from(
-                                        CellFilterCache.from(
-                                            CellFilterCellMatcher.from(
-                                                mHeightArea
-                                            )
-                                        ),
-                                        1.5,
-                                        1.5
-                                    )
+                                    1.5,
+                                    1.5
                                 )
                             )
-                        ]
+                        )
                     }
                 )
             ]