@woosh/meep-engine 2.62.0 → 2.64.0

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.62.0",
+  "version": "2.64.0",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/binary/EncodingBinaryBuffer.js

@@ -1,58 +1,22 @@
+import { BiMap } from "../collection/map/BiMap.js";
 import { BinaryBuffer } from "./BinaryBuffer.js";
 
-class Dictionary {
-    constructor() {
-        this.forward = new Map();
-        this.backward = new Map();
-    }
-
-    /**
-     *
-     * @param {*} value
-     * @param {number} address
-     */
-    add(value, address) {
-        this.forward.set(address, value);
-        this.backward.set(value, address);
-    }
-
-    /**
-     *
-     * @param {*} value
-     * @returns {number|undefined}
-     */
-    getAddress(value) {
-        return this.backward.get(value);
-    }
-
-    /**
-     *
-     * @param {number} address
-     * @returns {*}
-     */
-    getValue(address) {
-        return this.forward.get(address);
-    }
-}
+export class EncodingBinaryBuffer extends BinaryBuffer {
 
+    __dictionary = new BiMap();
 
-export class EncodingBinaryBuffer extends BinaryBuffer {
-    constructor() {
-        super();
-        this.__dictionary = new Dictionary();
-    }
 
     writeUTF8String(value) {
-        const address = this.__dictionary.getAddress(value);
+        const address = this.__dictionary.getKeyByValue(value);
 
         if (address === undefined) {
             this.writeUint8(0); //mark as complete value
 
-            const address1 = this.position;
+            const current_address = this.position;
 
             super.writeUTF8String(value);
 
-            this.__dictionary.add(value, address1);
+            this.__dictionary.add(value, current_address);
         } else {
             //write as reference
             this.writeUint32LE(1 | (address << 1));
@@ -72,7 +36,7 @@ export class EncodingBinaryBuffer extends BinaryBuffer {
 
             const address = header >> 1;
 
-            let value = this.__dictionary.getValue(address);
+            let value = this.__dictionary.getValueByKey(address);
 
             if (value === undefined) {
                 //remember position

package/src/core/binary/EncodingBinaryBuffer.spec.js

@@ -0,0 +1,16 @@
+import { EncodingBinaryBuffer } from "./EncodingBinaryBuffer.js";
+
+test("read/write strings", () => {
+
+    const buffer = new EncodingBinaryBuffer();
+
+    buffer.writeUTF8String("hello world");
+    buffer.writeUTF8String("cat");
+    buffer.writeUTF8String("hello world");
+
+    buffer.position = 0;
+
+    expect(buffer.readUTF8String()).toEqual("hello world");
+    expect(buffer.readUTF8String()).toEqual("cat");
+    expect(buffer.readUTF8String()).toEqual("hello world");
+});

package/src/core/binary/UINT16_MAX.js

@@ -0,0 +1,5 @@
+/**
+ * equal to `Math.pow(2,16) - 1`
+ * @type {number}
+ */
+export const UINT16_MAX = 65535;

package/src/core/bvh2/bvh3/EBBVHLeafProxy.js

@@ -50,8 +50,10 @@ export class EBBVHLeafProxy {
     unlink() {
         assert.equal(this.is_linked, true, 'not linked');
 
-        this.#tree.remove_leaf(this.#node_id);
-        this.#tree.release_node(this.#node_id);
+        const node_id = this.#node_id;
+
+        this.#tree.remove_leaf(node_id);
+        this.#tree.release_node(node_id);
 
         this.#node_id = -1;
         this.#tree = null;

package/src/core/bvh2/bvh3/ExplicitBinaryBoundingVolumeHierarchy.js

@@ -1,9 +1,9 @@
-import { aabb3_compute_surface_area } from "../../geom/3d/aabb/aabb3_compute_surface_area.js";
-import { min2 } from "../../math/min2.js";
-import { max2 } from "../../math/max2.js";
 import { assert } from "../../assert.js";
-import { typed_array_copy } from "../../collection/array/typed/typed_array_copy.js";
 import { array_copy } from "../../collection/array/array_copy.js";
+import { typed_array_copy } from "../../collection/array/typed/typed_array_copy.js";
+import { aabb3_compute_surface_area } from "../../geom/3d/aabb/aabb3_compute_surface_area.js";
+import { max2 } from "../../math/max2.js";
+import { min2 } from "../../math/min2.js";
 
 export const COLUMN_PARENT = 6;
 export const COLUMN_CHILD_1 = 7;
@@ -373,7 +373,7 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
     /**
      *
      * @param {number} id
-     * @param {number[]} result
+     * @param {number[]|Float32Array} result
      */
     node_get_aabb(id, result) {
         assert.isNonNegativeInteger(id, 'id');

package/src/core/bvh2/bvh3/query/BVHQueryIntersectsFrustum.js

@@ -1,18 +1,16 @@
-import { BVHQuery } from "./BVHQuery.js";
 import { aabb3_array_intersects_frustum_array } from "../../../geom/3d/aabb/aabb3_array_intersects_frustum_array.js";
+import { BVHQuery } from "./BVHQuery.js";
 
 const scratch_aabb = [];
 
 export class BVHQueryIntersectsFrustum extends BVHQuery {
-    constructor() {
-        super();
-
-        /**
-         * Collection of 6 planes: normal_x, normal_y, normal_z, offset
-         * @type {number[]}
-         */
-        this.frustum = [];
-    }
+
+    /**
+     * Collection of 6 planes: normal_x, normal_y, normal_z, offset
+     * @type {number[]}
+     */
+    frustum = [];
+
 
     /**
      *

package/src/core/bvh2/bvh3/query/BVHQueryIntersectsRay.js

@@ -1,21 +1,21 @@
-import { BVHQuery } from "./BVHQuery.js";
 import { aabb3_array_intersects_ray_array } from "../../../geom/3d/aabb/aabb3_array_intersects_ray_array.js";
+import { BVHQuery } from "./BVHQuery.js";
 
 const scratch_aabb = [];
 
 export class BVHQueryIntersectsRay extends BVHQuery {
-    constructor() {
-        super();
-
-        this.ray = [];
-    }
+    /**
+     *
+     * @type {number[]}
+     */
+    ray = [];
 
     /**
      *
      * @param {number[]|ArrayLike<number>} ray
      * @returns {BVHQueryIntersectsRay}
      */
-    static from(ray){
+    static from(ray) {
         const r = new BVHQueryIntersectsRay();
 
         r.ray = ray;

package/src/core/bvh2/bvh3/query/BVHQueryIntersectsSphere.js

@@ -0,0 +1,37 @@
+import { aabb3_array_intersects_sphere_array } from "../../../geom/3d/aabb/aabb3_array_intersects_sphere_array.js";
+import { BVHQuery } from "./BVHQuery.js";
+
+const scratch_aabb = [];
+
+export class BVHQueryIntersectsSphere extends BVHQuery {
+
+    /**
+     *
+     * @type {number[]}
+     */
+    sphere = [];
+
+    /**
+     *
+     * @param {number[]|ArrayLike<number>} sphere
+     * @returns {BVHQueryIntersectsRay}
+     */
+    static from(sphere) {
+        const r = new BVHQueryIntersectsSphere();
+
+        r.sphere = sphere;
+
+        return r;
+    }
+
+    evaluate(node, tree) {
+
+        tree.node_get_aabb(node, scratch_aabb);
+
+        // test node against the ray
+        return aabb3_array_intersects_sphere_array(
+            scratch_aabb,
+            this.sphere
+        );
+    }
+}

package/src/core/bvh2/bvh3/query/bvh_query_user_data_generic.js

@@ -1,5 +1,6 @@
-import { NULL_NODE } from "../ExplicitBinaryBoundingVolumeHierarchy.js";
+import { assert } from "../../../assert.js";
 import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
+import { NULL_NODE } from "../ExplicitBinaryBoundingVolumeHierarchy.js";
 
 const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
 
@@ -15,9 +16,15 @@ const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
  */
 export function bvh_query_user_data_generic(
     result, result_offset,
-    bvh,root, query
+    bvh, root, query
 ) {
 
+    assert.isArrayLike(result, 'result');
+    assert.isNonNegativeInteger(result_offset, 'result_offset');
+    assert.defined(bvh, 'bvh');
+    assert.isNonNegativeInteger(root, 'root');
+    assert.defined(query, 'query');
+
     if (root === NULL_NODE) {
         return 0;
     }
@@ -44,13 +51,14 @@ export function bvh_query_user_data_generic(
         // test node against the query
         const pass = query.evaluate(node, bvh);
 
-        if (!pass) {
+        if (pass === false) {
             continue;
         }
 
         const node_is_leaf = bvh.node_is_leaf(node);
 
-        if (!node_is_leaf) {
+        if (node_is_leaf === false) {
+            // binary-node
 
             // read in-order
             const child1 = bvh.node_get_child1(node);

package/src/core/bvh2/bvh3/query/bvh_query_user_data_generic.spec.js

@@ -0,0 +1,29 @@
+import { ExplicitBinaryBoundingVolumeHierarchy } from "../ExplicitBinaryBoundingVolumeHierarchy.js";
+import { bvh_query_user_data_generic } from "./bvh_query_user_data_generic.js";
+import { BVHQueryAny } from "./BVHQueryAny.js";
+
+test("all-accepting query", () => {
+    const bvh = new ExplicitBinaryBoundingVolumeHierarchy();
+
+    const leaf_a = bvh.allocate_node();
+    const leaf_b = bvh.allocate_node();
+
+    bvh.node_set_user_data(leaf_a, 7);
+    bvh.node_set_user_data(leaf_b, 13);
+
+    bvh.insert_leaf(leaf_a);
+    bvh.insert_leaf(leaf_b);
+
+    const result = [];
+
+    const count = bvh_query_user_data_generic(
+        result, 1,
+        bvh, bvh.root,
+        BVHQueryAny.INSTANCE
+    );
+
+    expect(count).toBe(2);
+    expect(result).toContain(7);
+    expect(result).toContain(13);
+
+});

package/src/core/cache/LoadingCache.js

@@ -1,7 +1,8 @@
 //
 
-import { Cache } from "./Cache.js";
+import { assert } from "../assert.js";
 import { current_time_in_seconds } from "../time/current_time_in_seconds.js";
+import { Cache } from "./Cache.js";
 
 /**
  * @template R
@@ -79,6 +80,8 @@ export class LoadingCache {
                     retryFailed = true
                 }) {
 
+        assert.isFunction(load, 'load');
+
         this.#internal = new Cache({
             maxWeight,
             keyWeigher,

package/src/core/collection/list/List.js

@@ -6,8 +6,8 @@
 import { assert } from "../../assert.js";
 import Signal from "../../events/signal/Signal.js";
 import { invokeObjectEquals } from "../../model/object/invokeObjectEquals.js";
-import { arraySetDiff } from "../array/arraySetDiff.js";
 import { arrayIndexByEquality } from "../array/arrayIndexByEquality.js";
+import { arraySetDiff } from "../array/arraySetDiff.js";
 
 
 /**
@@ -51,9 +51,12 @@ class List {
     /**
      * Retrieve element at a given position in the list
      * @param {number} index
-     * @returns {T}
+     * @returns {T|undefined}
      */
     get(index) {
+        assert.isNumber(index, 'index');
+        assert.isNonNegativeInteger(index, 'index');
+
         return this.data[index];
     }
 
@@ -63,6 +66,9 @@ class List {
      * @param {T} value
      */
     set(index, value) {
+        assert.isNumber(index, 'index');
+        assert.isNonNegativeInteger(index, 'index');
+
         const oldValue = this.data[index];
 
         if (oldValue !== undefined) {
@@ -183,7 +189,7 @@ class List {
     /**
      * Replace the data, replacements is performed surgically, meaning that diff is computed and add/remove operations are performed on the set
      * This method is tailored to work well with visualisation as only elements that's missing from the new set is removed, and only elements that are new to are added
-     * Conversely, relevant events are dispatched that a visualisation can observe. This results in fewer changes required to the visualisation
+     * Conversely, relevant events are dispatched that can observe. This results in fewer changes required to the visualisation
      * @param {T[]} newOutput
      */
     patch(newOutput) {

package/src/core/collection/map/BiMap.js

@@ -0,0 +1,49 @@
+/**
+ * Bi-directional map
+ * @template K,V
+ */
+export class BiMap {
+
+    /**
+     *
+     * @type {Map<K, V>}
+     */
+    forward = new Map();
+    /**
+     *
+     * @type {Map<V, K>}
+     */
+    backward = new Map();
+
+
+    /**
+     *
+     * @param {K} key
+     * @param {V} value
+     */
+    add(key, value) {
+        this.forward.set(value, key);
+        this.backward.set(key, value);
+    }
+
+    /**
+     *
+     * @param {V} value
+     * @returns {K|undefined}
+     */
+    getKeyByValue(value) {
+        return this.backward.get(value);
+    }
+
+    /**
+     *
+     * @param {K} address
+     * @returns {V|undefined}
+     */
+    getValueByKey(address) {
+        return this.forward.get(address);
+    }
+}
+
+BiMap.prototype.get = BiMap.prototype.getValueByKey;
+BiMap.prototype.set = BiMap.prototype.add;

package/src/core/geom/3d/aabb/aabb3_from_v3_array.js

@@ -1,10 +1,10 @@
-import { min2 } from "../../../math/min2.js";
-import { max2 } from "../../../math/max2.js";
 import { assert } from "../../../assert.js";
+import { max2 } from "../../../math/max2.js";
+import { min2 } from "../../../math/min2.js";
 
 /**
  *
- * @param {AABB3} result
+ * @param {ArrayLike<number>|number[]|Float32Array|AABB3} result
  * @param {number[]|ArrayLike<number>|Float32Array} input
  * @param {number} input_length length of the input array
  */
@@ -33,5 +33,12 @@ export function aabb3_from_v3_array(result, input, input_length) {
         z1 = max2(z, z1);
     }
 
-    result.setBounds(x0, y0, z0, x1, y1, z1);
+    // read out
+    result[0] = x0;
+    result[1] = y0;
+    result[2] = z0;
+
+    result[3] = x1;
+    result[4] = y1;
+    result[5] = z1;
 }

package/src/core/geom/Vector2.js

@@ -6,11 +6,12 @@
 import { assert } from "../assert.js";
 import Signal from "../events/signal/Signal.js";
 import { clamp } from "../math/clamp.js";
+import { EPSILON } from "../math/EPSILON.js";
+import { epsilonEquals } from "../math/epsilonEquals.js";
 import { lerp } from "../math/lerp.js";
 import { max2 } from "../math/max2.js";
 import { min2 } from "../math/min2.js";
-import { EPSILON } from "../math/EPSILON.js";
-import { epsilonEquals } from "../math/epsilonEquals.js";
+import { computeHashFloat } from "../primitives/numbers/computeHashFloat.js";
 
 class Vector2 {
     /**
@@ -542,8 +543,8 @@ class Vector2 {
      * @returns {number}
      */
     hash() {
-        const x = Math.sin(this.x) * 1367130550;
-        const y = Math.sin(this.y) * 1367130550;
+        const x = computeHashFloat(this.x);
+        const y = computeHashFloat(this.y);
 
         let hash = ((x << 5) - x) + y;
 
@@ -680,6 +681,7 @@ Vector2.one = Object.freeze(new Vector2(1, 1));
  * @type {boolean}
  */
 Vector2.prototype.isVector2 = true;
+
 /**
  *
  * @param {number} x0

package/src/engine/ecs/components/Tag.d.ts

@@ -17,6 +17,8 @@ export class Tag {
 
     containsOneOf(values: string[]): boolean
 
+    hash(): number
+
     equals(other: Tag): boolean
 
     static find(tags: string[], ecd: EntityComponentDataset): number[]

package/src/engine/ecs/components/Tag.js

@@ -3,8 +3,9 @@
  */
 
 
-import { computeStringHash } from "../../../core/primitives/strings/computeStringHash.js";
 import { assert } from "../../../core/assert.js";
+import { isArrayEqualStrict } from "../../../core/collection/array/isArrayEqualStrict.js";
+import { computeStringHash } from "../../../core/primitives/strings/computeStringHash.js";
 
 /**
  * Stores textual tags, useful for marking entities
@@ -12,7 +13,7 @@ import { assert } from "../../../core/assert.js";
 export class Tag {
     /**
      * @private
-     * @type {String[]}
+     * @type {string[]}
      */
     values = [];
 
@@ -194,41 +195,31 @@ export class Tag {
      * @return {boolean}
      */
     equals(other) {
-
-        const s0 = this.values;
-
-        const s1 = other.values;
-
-        const n0 = s0.length;
-        const n1 = s1.length;
-
-        if (n0 !== n1) {
-            //wrong length
-            return false;
-        }
-
-        for (let i = 0; i < n0; i++) {
-            const v0 = s0[i];
-            const v1 = s1[i];
-
-            if (v0 !== v1) {
-                return false;
-            }
-        }
-
-        return true;
+        return isArrayEqualStrict(this.values, other.values);
     }
 
     toJSON() {
         return this.values;
     }
 
+    /**
+     *
+     * @param {string[]|string} json
+     */
     fromJSON(json) {
+
+        this.clear();
+
         if (typeof json === "string") {
-            this.clear();
             this.add(json);
-        } else if (Array.isArray(json)) {
-            this.values = json;
+        } else {
+            assert.isArray(json, 'json');
+
+            const n = json.length;
+
+            for (let i = 0; i < n; i++) {
+                this.add(json[i]);
+            }
         }
     }
 

package/src/engine/ecs/components/Tag.spec.js

@@ -0,0 +1,47 @@
+import Tag from "./Tag.js";
+
+test("constructor", () => {
+    new Tag();
+});
+
+test("containsOneOf", () => {
+
+    const tag = Tag.fromJSON(['a', 'b']);
+
+    expect(tag.containsOneOf([])).toBe(false);
+    expect(tag.containsOneOf(['c'])).toBe(false);
+    expect(tag.containsOneOf(['a'])).toBe(true);
+    expect(tag.containsOneOf(['b'])).toBe(true);
+    expect(tag.containsOneOf(['a', 'b'])).toBe(true);
+
+});
+
+test("hash", () => {
+
+    const tag = Tag.fromJSON(['a', 'b']);
+
+    const hash = tag.hash();
+
+    expect(tag.hash()).toEqual(hash);
+
+    expect(typeof hash).toBe("number");
+    expect(Number.isInteger(hash)).toBe(true);
+});
+
+test("equals", () => {
+
+
+    const a = Tag.fromJSON(['a', 'b']);
+    const b = Tag.fromJSON([]);
+    const c = Tag.fromJSON(['a']);
+    const d = Tag.fromJSON(['b']);
+    const e = Tag.fromJSON(['a', 'b']);
+    const f = Tag.fromJSON(['a', 'c']);
+
+    expect(a.equals(b)).toBe(false);
+    expect(a.equals(c)).toBe(false);
+    expect(a.equals(d)).toBe(false);
+    expect(a.equals(e)).toBe(true);
+    expect(a.equals(f)).toBe(false);
+
+});

package/src/engine/ecs/fow/FogOfWar.js

@@ -208,6 +208,10 @@ export class FogOfWar {
         this.textureNeedsUpdate = true;
     }
 
+    concealAll(){
+        this.clear();
+    }
+
     /**
      *
      * @param {number} x

package/src/engine/ecs/fow/FogOfWarEditor.js

@@ -6,6 +6,9 @@ export class FogOfWarEditor extends ObjectEditor {
             properties: {
                 revealAll: {
                     type: Function
+                },
+                concealAll: {
+                    type: Function
                 }
             }
         };