@woosh/meep-engine 2.37.19 → 2.37.20

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
 }

package/generation/grid/GridData.js

@@ -1,10 +1,15 @@
 import { assert } from "../../core/assert.js";
 import { QuadTreeNode } from "../../core/geom/2d/quad-tree/QuadTreeNode.js";
 import { OffsetScaleTransform2D } from "../../engine/ecs/terrain/ecs/OffsetScaleTransform2D.js";
-import { MarkerMatchCounter } from "./MarkerMatchCounter.js";
 import { max2 } from "../../core/math/max2.js";
+import { qt_collect_by_circle } from "../../core/geom/2d/quad-tree/qt_collect_by_circle.js";
+import { v2_length_sqr } from "../../core/geom/Vector2.js";
 
-const scratch_match_counter = new MarkerMatchCounter();
+/**
+ *
+ * @type {QuadTreeDatum<MarkerNode>[]}
+ */
+const marker_collection = [];
 
 export class GridData {
     constructor() {
@@ -78,34 +83,6 @@ export class GridData {
         return undefined;
     }
 
-    /**
-     *
-     * @param {MarkerNode[]} result
-     * @param {number} x
-     * @param {number} y
-     * @param {number} radius
-     * @param {MarkerNodeMatcher} matcher
-     * @returns {number} match count
-     */
-    queryMarkersInCircle(result, x, y, radius, matcher) {
-        let count = 0;
-        this.markers.traverseCircleIntersections(x, y, this.radius, leaf => {
-            /**
-             *
-             * @type {MarkerNode}
-             */
-            const marker = leaf.data;
-
-            if (matcher.match(marker)) {
-                result.push(marker);
-
-                count++;
-            }
-        });
-
-        return count;
-    }
-
     /**
      *
      * @param {number} x
@@ -127,12 +104,34 @@ export class GridData {
      * @returns {number}
      */
     countMarkerInCircle(x, y, radius, matcher) {
-        scratch_match_counter.matcher = matcher;
-        scratch_match_counter.count = 0;
+        const match_count = qt_collect_by_circle(marker_collection, 0, this.markers, x, y, radius);
+
+        let result = 0;
+
+        for (let i = 0; i < match_count; i++) {
+            const marker_datum = marker_collection[i];
+
+            /**
+             *
+             * @type {MarkerNode|null}
+             */
+            const marker = marker_datum.data;
+
+            const distance_limit = radius + marker.size;
+
+            const distance_limit_sqr = distance_limit * distance_limit;
+
+            // check refined containment
+            if (v2_length_sqr(x - marker.position.x, y - marker.position.y) > distance_limit_sqr) {
+                continue;
+            }
 
-        this.markers.traverseCircleIntersections(x, y, radius, scratch_match_counter.exec, scratch_match_counter);
+            if (matcher.match(marker)) {
+                result++;
+            }
+        }
 
-        return scratch_match_counter.count;
+        return result;
     }
 
     /**
@@ -171,8 +170,8 @@ export class GridData {
         assert.isNumber(width, 'width');
         assert.isNumber(height, 'height');
 
-        assert.isNonNegativeInteger(width,'width');
-        assert.isNonNegativeInteger(height,'height');
+        assert.isNonNegativeInteger(width, 'width');
+        assert.isNonNegativeInteger(height, 'height');
 
         assert.isFiniteNumber(width, 'width');
         assert.isFiniteNumber(height, 'width');

package/generation/grid/MarkerMatchCounter.js

@@ -5,7 +5,7 @@ export class MarkerMatchCounter {
     constructor() {
         /**
          * Predicate
-         * @type {{match:function(T):boolean}|null}
+         * @type {MarkerNodeMatcher|null}
          */
         this.matcher = null;
         this.count = 0;
@@ -13,10 +13,12 @@ export class MarkerMatchCounter {
 
     /**
      *
-     * @param {QuadTreeDatum<T>} node
+     * @param {QuadTreeDatum<MarkerNode>} node
      */
     exec(node) {
-        if (this.matcher.match(node.data)) {
+        const marker = node.data;
+
+        if (this.matcher.match(marker)) {
             this.count++;
         }
     }

package/generation/markers/GridActionRuleSet.js

@@ -43,11 +43,6 @@ export class GridActionRuleSet {
          */
         this.matchOrigin = true;
 
-        /**
-         *
-         * @type {boolean}
-         */
-        this.allowEveryRotation = false;
     }
 
     /**
@@ -58,16 +53,20 @@ export class GridActionRuleSet {
      * @param {boolean} [allowEveryRotation]
      * @returns {GridActionRuleSet}
      */
-    static from({ rules, policy = RuleSelectionPolicyType.Sequential, pattern = [0, 0], allowEveryRotation = false }) {
+    static from({ rules, policy = RuleSelectionPolicyType.Sequential, pattern = [0, 0], allowEveryRotation }) {
         assert.enum(policy, RuleSelectionPolicyType, 'policy');
-        assert.typeOf(allowEveryRotation, 'boolean', 'allowEveryRotation');
+        assert.isArray(rules, 'rules');
+        assert.isArray(pattern, 'pattern');
 
         const r = new GridActionRuleSet();
 
         rules.forEach(r.add, r);
         r.policy = policy;
         r.pattern = pattern;
-        r.allowEveryRotation = allowEveryRotation;
+
+        if (allowEveryRotation !== undefined) {
+            console.warn('.allowEveryRotation is deprecated');
+        }
 
         return r;
     }
@@ -122,7 +121,6 @@ export class GridActionRuleSet {
         const patternSize = pattern.length;
 
         const matchOrigin = this.matchOrigin;
-        const allowEveryRotation = this.allowEveryRotation;
 
         const sampleCountX = width * resolution;
         const sampleCountY = height * resolution;
@@ -160,30 +158,17 @@ export class GridActionRuleSet {
                     const sampleOffsetX = pattern[sampleIndex++];
                     const sampleOffsetY = pattern[sampleIndex++];
 
+                    const ROTATION_COUNT = element.allowRotation ? 4 : 1;
 
-                    let final_sample_offset_x = sampleOffsetX;
-                    let final_sample_offset_y = sampleOffsetY;
-
-                    rotation_loop: for (let j = 0; j < 4; j++) {
-
+                    for (let j = 0; j < ROTATION_COUNT; j++) {
 
                         const rotation = j * PI_HALF;
 
-                        if (j > 0) {
-                            if (!element.allowRotation) {
-                                break rotation_loop;
-                            } else {
-
-
-                                const sin = Math.sin(rotation);
-                                const cos = Math.cos(rotation);
+                        const sin = Math.sin(rotation);
+                        const cos = Math.cos(rotation);
 
-                                final_sample_offset_x = sampleOffsetX * cos - sampleOffsetY * sin;
-                                final_sample_offset_y = sampleOffsetX * sin + sampleOffsetY * cos;
-
-                            }
-
-                        }
+                        const final_sample_offset_x = sampleOffsetX * cos - sampleOffsetY * sin;
+                        const final_sample_offset_y = sampleOffsetX * sin + sampleOffsetY * cos;
 
                         const p_x = final_sample_offset_x + x;
                         const p_y = final_sample_offset_y + y;
@@ -198,7 +183,7 @@ export class GridActionRuleSet {
                         }
 
                         if (!match) {
-                            continue rotation_loop;
+                            continue;
                         }
 
                         const roll = random();
@@ -209,9 +194,7 @@ export class GridActionRuleSet {
 
                             element.execute(grid, p_x, p_y, rotation);
 
-                            if (!allowEveryRotation) {
-                                break sampling_loop;
-                            }
+                            break sampling_loop;
                         }
 
                     }

package/generation/markers/GridCellActionPlaceMarker.js

@@ -3,6 +3,7 @@ import { MarkerNode } from "./MarkerNode.js";
 import { Transform } from "../../engine/ecs/transform/Transform.js";
 import Vector2 from "../../core/geom/Vector2.js";
 import { assert } from "../../core/assert.js";
+import Vector3 from "../../core/geom/Vector3.js";
 
 export class GridCellActionPlaceMarker extends GridCellAction {
     constructor() {
@@ -180,16 +181,17 @@ export class GridCellActionPlaceMarker extends GridCellAction {
             target_y * transform.scale_y + transform.offset_y
         );
 
-        node.transform.rotation.fromEulerAnglesXYZ(0, -rotation, 0);
+        node.transform.rotation.fromAxisAngle(Vector3.down, rotation);
 
         node.transform.multiplyTransforms(node.transform, this.transform);
 
         //add tags
         const tags = this.tags;
-        const tagCount = tags.length;
-        for (let i = 0; i < tagCount; i++) {
+        const tag_count = tags.length;
+        const node_tags = node.tags;
+        for (let i = 0; i < tag_count; i++) {
             const tag = tags[i];
-            node.tags.push(tag);
+            node_tags.push(tag);
         }
 
         //write properties
@@ -199,13 +201,9 @@ export class GridCellActionPlaceMarker extends GridCellAction {
 
         //apply transformations
         const transformers = this.transformers;
-        const transformerCount = transformers.length;
+        const transformer_count = transformers.length;
 
-        if (node.type === "Virtual" && rotation !== 0) {
-            debugger;
-        }
-
-        for (let i = 0; i < transformerCount; i++) {
+        for (let i = 0; i < transformer_count; i++) {
             const transformer = transformers[i];
             node = transformer.transform(node, data);
         }

package/generation/markers/debug/visualizeMarkers.js

@@ -51,8 +51,14 @@ function CircleGeometry(radius, arc) {
  * @param {GridData} grid
  * @param {EntityComponentDataset} ecd
  * @param {MarkerNodeMatcher} marker_filter
+ * @param {boolean} [display_data]
  */
-export function visualizeMarkers({ grid, ecd, marker_filter = MarkerNodeMatcherAny.INSTANCE }) {
+export function visualizeMarkers({
+                                     grid,
+                                     ecd,
+                                     marker_filter = MarkerNodeMatcherAny.INSTANCE,
+                                     display_data = true
+                                 }) {
 
     /**
      *
@@ -85,7 +91,8 @@ export function visualizeMarkers({ grid, ecd, marker_filter = MarkerNodeMatcherA
      */
     const terrain = obtainTerrain(ecd);
 
-    const geometry_0 = new TetrahedronBufferGeometry(0.05, 2);
+    const marker_radius = 0.05;
+    const geometry_0 = new TetrahedronBufferGeometry(marker_radius, 2);
 
     const geometry_cylinder = CircleGeometry(1, 1);
 
@@ -110,63 +117,76 @@ export function visualizeMarkers({ grid, ecd, marker_filter = MarkerNodeMatcherA
         mark_1.position.copy(markerNode.transform.position);
         mark_1.position.sub(v3);
 
-        const line_geometry = new BufferGeometry();
-        line_geometry.setFromPoints([
-            mark_0.position,
-            mark_1.position
-        ]);
-
-        const mark_line = new Line(line_geometry, m_line);
-
-
         const mark_size = new Line(geometry_cylinder, m3);
         mark_size.scale.set(markerNode.size, markerNode.size, markerNode.size);
 
 
         g.add(mark_0);
-        g.add(mark_1);
+
+        if (mark_1.position.distanceToSquared(mark_0.position) > marker_radius * marker_radius * 0.2) {
+            // only draw second marker if they are sufficiently far apart
+
+            const line_geometry = new BufferGeometry();
+            line_geometry.setFromPoints([
+                mark_0.position,
+                mark_1.position
+            ]);
+
+            const mark_line = new Line(line_geometry, m_line);
+
+            g.add(mark_1);
+            g.add(mark_line);
+        }
+
         g.add(mark_size);
-        g.add(mark_line);
+
+        const entityBuilder = new EntityBuilder();
 
         const renderable = new Renderable(g);
         renderable.computeBoundsFromObject();
 
-        const props = [];
+        if (display_data) {
+            const props = [];
 
-        props.push(`TYPE: ${markerNode.type}`);
+            props.push(`TYPE: ${markerNode.type}`);
 
-        for (const propertyKey in markerNode.properties) {
-            let propValue = formatValue(markerNode.properties[propertyKey]);
+            for (const propertyKey in markerNode.properties) {
+                let propValue = formatValue(markerNode.properties[propertyKey]);
 
-            props.push(`${propertyKey}:${propValue}`);
-        }
+                props.push(`${propertyKey}:${propValue}`);
+            }
 
-        props.push(`# [x: ${formatValue(markerNode.position.x)}, y: ${formatValue(markerNode.position.y)}]`);
-        props.push(`# [size: ${formatValue(markerNode.size)}]`);
+            props.push(`# [x: ${formatValue(markerNode.position.x)}, y: ${formatValue(markerNode.position.y)}]`);
+            props.push(`# [size: ${formatValue(markerNode.size)}]`);
 
-        for (let j = 0; j < markerNode.tags.length; j++) {
-            const tag = markerNode.tags[j];
+            for (let j = 0; j < markerNode.tags.length; j++) {
+                const tag = markerNode.tags[j];
 
-            props.push(`# T: ${tag}`);
-        }
+                props.push(`# T: ${tag}`);
+            }
 
 
-        const v = new LabelView(props.join('\n'), { classList: ['__debug-plaque'] });
-        v.css({
-            position: 'absolute',
-            whiteSpace: 'pre',
-            left: 0,
-            top: 0
-        })
+            const v = new LabelView(props.join('\n'), { classList: ['__debug-plaque'] });
+            v.css({
+                position: 'absolute',
+                whiteSpace: 'pre',
+                left: 0,
+                top: 0
+            })
+
+            entityBuilder
+                .add(new HeadsUpDisplay())
+                .add(new ViewportPosition())
+                .add(GUIElement.fromView(v))
+            ;
+        }
 
         const t = new Transform();
 
         t.position.copy(v3);
 
-        new EntityBuilder()
-            .add(new HeadsUpDisplay())
-            .add(new ViewportPosition())
-            .add(GUIElement.fromView(v))
+
+        entityBuilder
             .add(renderable)
             .add(t)
             .build(ecd);

package/generation/markers/emitter/MarkerNodeEmitterFromAction.js

@@ -1,7 +1,7 @@
 import { MarkerNodeEmitter } from "./MarkerNodeEmitter.js";
 import { assert } from "../../../core/assert.js";
 
-export class MarkerNodeEmitterFromAction extends MarkerNodeEmitter{
+export class MarkerNodeEmitterFromAction extends MarkerNodeEmitter {
     constructor() {
         super();
 
@@ -18,8 +18,8 @@ export class MarkerNodeEmitterFromAction extends MarkerNodeEmitter{
      * @param {GridCellActionPlaceMarker[]} actions
      * @return {MarkerNodeEmitterFromAction}
      */
-    static from(actions){
-assert.isArray(actions,'actions');
+    static from(actions) {
+        assert.isArray(actions, 'actions');
 
         for (let i = 0; i < actions.length; i++) {
 
@@ -27,11 +27,11 @@ assert.isArray(actions,'actions');
             assert.equal(action.isGridCellActionPlaceMarker, true, 'action.isGridCellActionPlaceMarker !== true');
         }
 
-         const r = new MarkerNodeEmitterFromAction();
+        const r = new MarkerNodeEmitterFromAction();
 
-         r.actions = actions;
+        r.actions = actions;
 
-         return r;
+        return r;
     }
 
     initialize(data, seed) {
@@ -41,7 +41,7 @@ assert.isArray(actions,'actions');
         for (let i = 0; i < n; i++) {
             const action = actions[i];
 
-            action.initialize(data,seed);
+            action.initialize(data, seed);
         }
     }
 
@@ -54,7 +54,7 @@ assert.isArray(actions,'actions');
 
             const action = actions[i];
 
-            const node = action.buildNode(data,x,y,rotation);
+            const node = action.buildNode(data, x, y, rotation);
 
             consumer.consume(node);