@woosh/meep-engine 2.37.18 → 2.38.0

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/generators/interactive/mir_generator_place_buff_objects.js

@@ -23,6 +23,7 @@ import { MirMarkerTypes } from "../../../../../generator/MirMarkerTypes.js";
 import { GridPatternMatcherCell } from "../../../rules/cell/GridPatternMatcherCell.js";
 import { BuffObjectTypes } from "../../../../../../generator/BuffObjectTypes.js";
 import { UnlockableElementsManager } from "../../../../../../model/unlocks/UnlockableElementsManager.js";
+import { GridCellActionSequence } from "../../../placement/action/util/GridCellActionSequence.js";
 
 const TAG_MAJOR = 'Major Buff';
 const TAG_MINOR = 'Minor Buff';
@@ -112,7 +113,7 @@ function makeMajorRule(tag) {
                 )
             )
         ),
-        actions: [
+        action: GridCellActionSequence.from([
             placeTags,
             clearTags,
             GridCellActionPlaceMarker.from({
@@ -121,7 +122,7 @@ function makeMajorRule(tag) {
                 tags: [MirMarkerTypes.BuffObject, TAG_MAJOR]
             }),
             placeRoadMarkers
-        ],
+        ]),
         probability: CellFilterLiteralFloat.from(0.1)
     });
 }
@@ -151,7 +152,7 @@ function makeMinorRule(tag) {
                 )
             )
         ),
-        actions: [
+        action: GridCellActionSequence.from([
             placeTags,
             clearTags,
             GridCellActionPlaceMarker.from({
@@ -159,7 +160,7 @@ function makeMinorRule(tag) {
                 size: 0.52,
                 tags: [MirMarkerTypes.BuffObject, TAG_MINOR]
             })
-        ],
+        ]),
         probability: CellFilterLiteralFloat.from(0.1)
     });
 }
@@ -185,7 +186,7 @@ function makeUtilityRule(tag, frequency = 17) {
                 )
             )
         ),
-        actions: [
+        action: GridCellActionSequence.from([
             placeTags,
             clearTags,
             GridCellActionPlaceMarker.from({
@@ -193,7 +194,7 @@ function makeUtilityRule(tag, frequency = 17) {
                 size: 0.52,
                 tags: [MirMarkerTypes.BuffObject, TAG_UTILITY]
             })
-        ],
+        ]),
         probability: CellFilterLiteralFloat.from(0.1)
     });
 }

package/generation/example/generators/mir_generator_place_bases.js

@@ -21,9 +21,12 @@ import { MarkerNodeMatcherAny } from "../../markers/matcher/MarkerNodeMatcherAny
 import { MarkerNodeEmitterFromAction } from "../../markers/emitter/MarkerNodeEmitterFromAction.js";
 import { Transform } from "../../../engine/ecs/transform/Transform.js";
 import { MarkerNodeTransformerOffsetPosition } from "../../markers/transform/MarkerNodeTransformerOffsetPosition.js";
-import { MarkerNodeTransformerRecordUniqueRandomEnum } from "../../markers/transform/MarkerNodeTransformerRecordUniqueRandomEnum.js";
+import {
+    MarkerNodeTransformerRecordUniqueRandomEnum
+} from "../../markers/transform/MarkerNodeTransformerRecordUniqueRandomEnum.js";
 import { MirMarkerTypes } from "../../../../generator/MirMarkerTypes.js";
 import { MirMarkerTags } from "../../../../generator/MirMarkerTags.js";
+import { GridCellActionSequence } from "../../placement/action/util/GridCellActionSequence.js";
 
 const pMatcher = new CellMatcherGridPattern();
 
@@ -79,7 +82,7 @@ for (let i = 0; i < 100; i++) {
 
 const rule = GridCellPlacementRule.from({
     matcher: pMatcher,
-    actions: [
+    action: GridCellActionSequence.from([
         placeTags,
         clearTags,
         MarkerNodeEmitterGridCellAction.from(
@@ -134,7 +137,8 @@ const rule = GridCellPlacementRule.from({
             })
         ),
         placeRoadConnectors
-    ], probability: CellFilterLiteralFloat.from(0.1)
+    ]),
+    probability: CellFilterLiteralFloat.from(0.1)
 });
 
 rule.allowRotation = false;

package/generation/example/generators/mir_generator_place_road_decorators.js

@@ -46,9 +46,9 @@ const placeMarker = GridCellActionPlaceMarker.from({ type: 'Road Junction Decora
 placeMarker.addTag(TAG_ROAD_DECORATOR);
 
 const ruleBend90 = GridCellPlacementRule.from({
-    matcher: matchBend90, actions: [
-        placeMarker
-    ], probability: CellFilterLiteralFloat.from(0.1)
+    matcher: matchBend90,
+    action:placeMarker,
+    probability: CellFilterLiteralFloat.from(0.1)
 });
 
 

package/generation/example/generators/mir_generator_place_starting_point.js

@@ -16,6 +16,7 @@ import { MirMarkerTypes } from "../../../../generator/MirMarkerTypes.js";
 import { MarkerNodeTransformerRemoveTag } from "../../markers/transform/MarkerNodeTransformerRemoveTag.js";
 import { MirMarkerTags } from "../../../../generator/MirMarkerTags.js";
 import { MarkerNodeTransformerSequence } from "../../markers/transform/MarkerNodeTransformerSequence.js";
+import { GridCellActionSequence } from "../../placement/action/util/GridCellActionSequence.js";
 
 const MATCH_STARTING_POINT = CellMatcherLayerBitMaskTest.from(GridTags.StartingPoint, MirGridLayers.Tags);
 
@@ -30,7 +31,7 @@ pattern.addRule(0, -1, CellMatcherLayerBitMaskTest.from(GridTags.Base, MirGridLa
 const rule = GridCellPlacementRule.from(
     {
         matcher: pattern,
-        actions: [
+        action: GridCellActionSequence.from([
             GridCellActionPlaceTags.from(GridTags.StartingPoint | GridTags.Occupied, MirGridLayers.Tags),
             GridCellActionPlaceMarker.from({ type: MirMarkerTypes.StartingPoint }),
             // transfer ownership of any base within some distance to the player
@@ -42,7 +43,7 @@ const rule = GridCellPlacementRule.from(
                     MarkerNodeTransformerRemoveTag.from(MirMarkerTags.Encounter)
                 ])
             )
-        ]
+        ])
     }
 );
 

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);
     }
 }

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

@@ -0,0 +1,55 @@
+import { CellFilterUnaryOperation } from "../../core/CellFilterUnaryOperation.js";
+import { assert } from "../../../../core/assert.js";
+import { bell_membership_function } from "../../../../core/math/bell_membership_function.js";
+
+/**
+ * @see "dbellmf" function from Matlab
+ * @see https://codecrucks.com/what-is-fuzzy-membership-function-complete-guide/
+ * @see https://researchhubs.com/post/maths/fundamentals/bell-shaped-function.html
+ */
+export class CellFilterMembershipGeneralizedBell extends CellFilterUnaryOperation {
+    constructor() {
+        super();
+
+
+        /**
+         * Controls window, larger value = larger window. Function will return exactly 0.5 at this distance away from center
+         * @type {number}
+         */
+        this.a = 0;
+
+        /**
+         * Slope, larger slope makes function's tails sharper, meaning that values fall off faster away from center
+         * @type {number}
+         */
+        this.b = 0;
+        /**
+         * Controls center of the bell
+         * @type {number}
+         */
+        this.c = 0;
+    }
+
+    static from(source, a = 1, b = 1, c = 0) {
+        assert.equal(source.isCellFilter, true, 'source.isCellFilter !== true');
+
+        assert.isNumber(a, 'a');
+        assert.isNumber(b, 'b');
+        assert.isNumber(c, 'c');
+
+        const r = new CellFilterMembershipGeneralizedBell();
+
+        r.a = a;
+        r.b = b;
+        r.c = c;
+
+        r.source = source;
+
+        return r;
+    }
+
+    operation(v) {
+        return bell_membership_function(v, this.a, this.b, this.c);
+    }
+
+}

package/generation/filtering/numeric/sampling/AbstractCellFilterSampleGridLayer.js

@@ -0,0 +1,42 @@
+import { CellFilter } from "../../CellFilter.js";
+
+export class AbstractCellFilterSampleGridLayer extends CellFilter {
+    constructor() {
+        super();
+
+        /**
+         *
+         * @type {string}
+         */
+        this.layerId = null;
+
+        /**
+         *
+         * @type {GridDataLayer}
+         * @private
+         */
+        this.__layer = null;
+
+        this.__u_scale = 0;
+        this.__v_scale = 0;
+        /**
+         *
+         * @type {Sampler2D}
+         * @private
+         */
+        this.__sampler = null;
+    }
+
+    initialize(grid, seed) {
+        super.initialize(grid, seed);
+
+        this.__layer = grid.getLayerById(this.layerId);
+
+        // cache required values
+        this.__sampler = this.__layer.sampler;
+
+        this.__u_scale = this.__sampler.width / grid.width;
+        this.__v_scale = this.__sampler.height / grid.height;
+    }
+
+}

package/generation/filtering/numeric/sampling/CellFilterSampleLayerCubic.js

@@ -0,0 +1,36 @@
+import { AbstractCellFilterSampleGridLayer } from "./AbstractCellFilterSampleGridLayer.js";
+import { assert } from "../../../../core/assert.js";
+
+export class CellFilterSampleLayerCubic extends AbstractCellFilterSampleGridLayer {
+
+    /**
+     *
+     * @param {string} layer
+     * @returns {CellFilterSampleLayerCubic}
+     */
+    static from(layer) {
+        assert.typeOf(layer, 'string', 'layer');
+
+        const r = new CellFilterSampleLayerCubic();
+
+        r.layerId = layer;
+
+        return r;
+    }
+
+    execute(grid, x, y, rotation) {
+
+        //convert to UV
+        const sampler_x = x * this.__u_scale;
+        const sampler_y = y * this.__v_scale;
+
+
+        /**
+         *
+         * @type {Sampler2D}
+         */
+        const sampler = this.__sampler;
+
+        return sampler.sampleChannelBicubic(sampler_x, sampler_y, 0);
+    }
+}

package/generation/filtering/numeric/sampling/CellFilterSampleLayerLinear.js

@@ -0,0 +1,41 @@
+import { assert } from "../../../../core/assert.js";
+import { AbstractCellFilterSampleGridLayer } from "./AbstractCellFilterSampleGridLayer.js";
+
+export class CellFilterSampleLayerLinear extends AbstractCellFilterSampleGridLayer {
+
+    /**
+     *
+     * @param {string} layer
+     * @returns {CellFilterSampleLayerLinear}
+     */
+    static from(layer) {
+        assert.typeOf(layer, 'string', 'layer');
+
+        const r = new CellFilterSampleLayerLinear();
+
+        r.layerId = layer;
+
+        return r;
+    }
+
+    execute(grid, x, y, rotation) {
+
+        //convert to UV
+        const sampler_x = x * this.__u_scale;
+        const sampler_y = y * this.__v_scale;
+
+
+        /**
+         *
+         * @type {Sampler2D}
+         */
+        const sampler = this.__sampler;
+
+        const channel_value = sampler.sampleChannelBilinear(sampler_x, sampler_y, 0);
+
+        assert.notNaN(channel_value, 'channel_value');
+
+        return channel_value;
+    }
+}
+

package/generation/grid/GridData.d.ts

@@ -1,3 +1,7 @@
-export class GridData{
+import {OffsetScaleTransform2D} from "../../engine/ecs/terrain/ecs/OffsetScaleTransform2D";
 
+export class GridData {
+    readonly transform: OffsetScaleTransform2D
+
+    resize(x: number, y: number): void
 }