@woosh/meep-engine 2.48.17 → 2.48.19

package/package.json

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

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

@@ -0,0 +1,13 @@
+import { dec2hex } from "./dec2hex.js";
+
+test("zero padding", () => {
+    expect(dec2hex(0)).toBe("00");
+    expect(dec2hex(10)).toBe("0a");
+});
+
+test("two digits", () => {
+
+    expect(dec2hex(16)).toBe("10");
+    expect(dec2hex(255)).toBe("ff");
+
+});

package/src/core/bvh2/bvh3/ExplicitBinaryBoundingVolumeHierarchy.d.ts

@@ -1,6 +1,8 @@
 export class ExplicitBinaryBoundingVolumeHierarchy {
     readonly root: number
 
+    node_capacity: number
+
     allocate_node(): number
 
     release_node(node: number): void
@@ -19,6 +21,22 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
 
     node_get_user_data(node: number): number
 
+    node_set_child1(node: number, child1: number): void
+
+    node_get_child1(node: number): number
+
+    node_set_child2(node: number, child1: number): void
+
+    node_get_child2(node: number): number
+
+    node_set_parent(node: number, parent: number): void
+
+    node_get_parent(node: number): number
+
+    node_set_height(node: number, height: number): void
+
+    node_get_height(node: number): number
+
     release_all(): void
 
     trim(): void

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

@@ -130,6 +130,18 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
         return this.__capacity;
     }
 
+    /**
+     *
+     * @param {number} v
+     */
+    set node_capacity(v) {
+        if (this.__size > v) {
+            throw new Error(`Can't shrink capacity to ${v}, because it's below occupancy(${this.__size}).`);
+        }
+
+        this.__set_capacity(v);
+    }
+
     __grow_capacity() {
         const new_capacity = Math.ceil(max2(
             this.__capacity * CAPACITY_GROW_MULTIPLIER,
@@ -145,6 +157,12 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
      * @private
      */
     __set_capacity(new_capacity) {
+        assert.isNonNegativeInteger(new_capacity, 'new_capacity');
+
+        if (this.__capacity === new_capacity) {
+            // already at the exact desired capacity
+            return;
+        }
 
         const old_data_uint32 = this.__data_uint32;
 

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

@@ -162,3 +162,59 @@ test("release_all with 1 leaf", () => {
 
     expect(bvh.root).toBe(NULL_NODE);
 });
+
+test("capacity grows as necessary when allocating", () => {
+    const bvh = new ExplicitBinaryBoundingVolumeHierarchy();
+
+    bvh.node_capacity = 1;
+
+    bvh.allocate_node();
+
+    bvh.allocate_node();
+
+    expect(bvh.node_capacity).toBeGreaterThanOrEqual(2);
+});
+
+test("trim sets capacity to exact allocated size", () => {
+    const bvh = new ExplicitBinaryBoundingVolumeHierarchy();
+
+    bvh.node_capacity = 1;
+
+    bvh.allocate_node();
+
+    bvh.allocate_node();
+
+    bvh.trim();
+
+    expect(bvh.node_capacity).toBe(2);
+});
+
+
+test("node property setters/getters", () => {
+
+    const bvh = new ExplicitBinaryBoundingVolumeHierarchy();
+
+    const node = bvh.allocate_node();
+
+    bvh.node_set_user_data(node, 3);
+
+    expect(bvh.node_get_user_data(node)).toBe(3);
+
+    bvh.node_set_child1(node, 7);
+    bvh.node_set_child2(node, 11);
+    bvh.node_set_parent(node, 13);
+    bvh.node_set_height(node, 17);
+
+    const expected_aabb = new Float32Array([1.1, 3.2, 7.3, 11.4, 13.5, 17.6]);
+    bvh.node_set_aabb(node, expected_aabb);
+
+    expect(bvh.node_get_child1(node)).toBe(7);
+    expect(bvh.node_get_child2(node)).toBe(11);
+    expect(bvh.node_get_parent(node)).toBe(13);
+    expect(bvh.node_get_height(node)).toBe(17);
+
+    const actual_aabb = [];
+    bvh.node_get_aabb(node, actual_aabb)
+
+    expect(actual_aabb).toEqual(Array.from(expected_aabb));
+});

package/src/core/cache/Cache.d.ts

@@ -1,3 +1,5 @@
+import Signal from "../events/signal/Signal";
+
 export class Cache<K, V> {
     constructor({
                     maxWeight,
@@ -15,6 +17,9 @@ export class Cache<K, V> {
         capacity?: number
     })
 
+    readonly onEvicted: Signal<K, V>
+    readonly onRemoved: Signal<K, V>
+
     readonly weight: number
     readonly maxWeight: number
 

package/src/core/cache/Cache.js

@@ -3,6 +3,7 @@ import { HashMap } from "../collection/HashMap.js";
 import Signal from "../events/signal/Signal.js";
 import { returnOne, returnZero, strictEquals } from "../function/Functions.js";
 import { CacheElement } from "./CacheElement.js";
+import { collectIteratorValueToArray } from "../collection/IteratorUtils.js";
 
 /**
  * TODO validate hashes of held elements to keep them up to date. Keys are assumed to be immutable, but this assumption may be broken by users
@@ -419,7 +420,13 @@ export class Cache {
      * Remove all elements from the cache
      */
     clear() {
-        const keys = Array.from(this.data.keys());
+        /**
+         *
+         * @type {Key[]}
+         */
+        const keys = [];
+
+        collectIteratorValueToArray(keys,this.data.keys());
 
         const n = keys.length;
         for (let i = 0; i < n; i++) {

package/src/core/cache/Cache.spec.js

@@ -88,11 +88,55 @@ test("remove method", () => {
     expect(cache.get("a")).toBe(null);
 });
 
-test("replacing element with the same key",()=>{
+test("replacing element with the same key", () => {
     const cache = new Cache();
 
-    cache.put("a","b");
-    cache.put("a","c");
+    cache.put("a", "b");
+    cache.put("a", "c");
 
     expect(cache.get("a")).toBe("c");
 });
+
+test("getOrCompute", () => {
+
+    const cache = new Cache();
+
+    const tokens = [1, 3, 5];
+
+    const compute = () => tokens.shift();
+
+    expect(cache.getOrCompute("x", compute)).toBe(1);
+
+    expect(cache.get("x")).toBe(1);
+
+    expect(cache.getOrCompute("x", compute)).toBe(1);
+
+    expect(cache.getOrCompute("y", compute)).toBe(3);
+
+    expect(cache.get("y")).toBe(3);
+
+    expect(cache.getOrCompute("y", compute)).toBe(3);
+
+})
+
+test("clear on empty does not throw", () => {
+
+    const cache = new Cache();
+
+    cache.clear();
+
+});
+
+test("clear with a single entry", () => {
+
+    const cache = new Cache();
+
+    cache.set("x", 1);
+
+    expect(cache.contains("x")).toBe(true);
+
+    cache.clear();
+
+    expect(cache.contains("x")).toBe(false);
+
+});

package/src/core/codegen/LineBuilder.js

@@ -3,146 +3,157 @@
  */
 
 
-/**
- *
- * @param {String} text
- * @param {Number} indent
- * @constructor
- */
-const Line = function (text, indent) {
-    this.text = text;
-    this.indentation = indent;
-};
+class Line {
+    /**
+     *
+     * @param {string} text
+     * @param {number} indent
+     * @constructor
+     */
+    constructor(text, indent) {
+        this.text = text;
+        this.indentation = indent;
+    }
+}
+
+class LineBuilder {
 
-const LineBuilder = function () {
     /**
      *
-     * @type {Array.<Line>}
+     * @type {Line[]}
      */
-    this.lines = [];
-    this.indentation = 0;
-    this.indentSpaces = 4;
-};
+    lines = [];
+    /**
+     *
+     * @type {number}
+     */
+    indentation = 0;
+    /**
+     *
+     * @type {number}
+     */
+    indentSpaces = 4;
 
-/**
- *
- * @param {string} text
- * @returns {LineBuilder}
- */
-LineBuilder.fromText = function (text) {
-    const r = new LineBuilder();
+    /**
+     *
+     * @return {boolean}
+     * @param {string} term
+     */
+    containsSubstring(term) {
+        const lines = this.lines;
+        const n = lines.length;
+        for (let i = 0; i < n; i++) {
+            const line = lines[i];
 
-    const lines = text.split('\n');
+            const termIndex = line.text.indexOf(term);
 
-    const n = lines.length;
+            if (termIndex !== -1) {
+                return true;
+            }
+        }
 
-    for (let i = 0; i < n; i++) {
+        return false;
+    }
 
-        r.add(lines[i]);
+    /**
+     *
+     * @returns {LineBuilder}
+     */
+    indent() {
+        this.indentation++;
+        return this;
+    }
 
+    /**
+     *
+     * @returns {LineBuilder}
+     */
+    dedent() {
+        this.indentation--;
+        return this;
     }
 
-    return r;
-}
+    /**
+     *
+     * @param {string} line_text
+     * @returns {LineBuilder}
+     */
+    add(line_text) {
+        const line = new Line(line_text, this.indentation);
+        this.lines.push(line);
+        return this;
+    }
 
-/**
- *
- * @return {boolean}
- * @param {string} term
- */
-LineBuilder.prototype.containsSubstring = function (term) {
-    const lines = this.lines;
-    const n = lines.length;
-    for (let i = 0; i < n; i++) {
-        const line = lines[i];
+    /**
+     *
+     * @param {LineBuilder} lines
+     */
+    addLines(lines) {
 
-        const termIndex = line.text.indexOf(term);
+        const other_lines = lines.lines;
 
-        if (termIndex !== -1) {
-            return true;
-        }
-    }
+        const other_line_count = other_lines.length;
 
-    return false;
-};
+        for (let i = 0; i < other_line_count; i++) {
+            const otherLine = other_lines[i];
 
-/**
- *
- * @returns {LineBuilder}
- */
-LineBuilder.prototype.indent = function () {
-    this.indentation++;
-    return this;
-};
+            const line = new Line(otherLine.text, otherLine.indentation + this.indentation);
 
-/**
- *
- * @returns {LineBuilder}
- */
-LineBuilder.prototype.dedent = function () {
-    this.indentation--;
-    return this;
-};
+            this.lines.push(line);
+        }
 
-/**
- *
- * @param {string} l
- * @returns {LineBuilder}
- */
-LineBuilder.prototype.add = function (l) {
-    const line = new Line(l, this.indentation);
-    this.lines.push(line);
-    return this;
-};
+    }
 
-/**
- *
- * @param {LineBuilder} lines
- */
-LineBuilder.prototype.addLines = function (lines) {
+    clear() {
+        this.lines = [];
+        this.indentation = 0;
+        this.indentSpaces = 4;
+    }
+
+    /**
+     *
+     * @returns {string}
+     */
+    build() {
+        const result = [];
+        let i, j, l;
 
-    const other_lines = lines.lines;
 
-    const other_line_count = other_lines.length;
+        const lines = this.lines;
+        for (i = 0, l = lines.length; i < l; i++) {
+            const line = lines[i];
 
-    for (let i = 0; i < other_line_count; i++) {
-        const otherLine = other_lines[i];
+            let indentString = '';
+            for (j = 0; j < line.indentation * this.indentSpaces; j++) {
+                indentString += ' ';
+            }
 
-        const line = new Line(otherLine.text, otherLine.indentation + this.indentation);
+            result.push(indentString + line.text);
+        }
 
-        this.lines.push(line);
+        return result.join('\n');
     }
 
-}
+    /**
+     *
+     * @param {string} text
+     * @returns {LineBuilder}
+     */
+    static fromText(text) {
+        const r = new LineBuilder();
 
-LineBuilder.prototype.clear = function () {
-    this.lines = [];
-    this.indentation = 0;
-    this.indentSpaces = 4;
-};
+        const lines = text.split('\n');
 
-/**
- *
- * @returns {string}
- */
-LineBuilder.prototype.build = function () {
-    const result = [];
-    let i, j, l;
+        const n = lines.length;
 
+        for (let i = 0; i < n; i++) {
 
-    const lines = this.lines;
-    for (i = 0, l = lines.length; i < l; i++) {
-        const line = lines[i];
+            r.add(lines[i]);
 
-        let indentString = '';
-        for (j = 0; j < line.indentation * this.indentSpaces; j++) {
-            indentString += ' ';
         }
 
-        result.push(indentString + line.text);
+        return r;
     }
-
-    return result.join('\n');
-};
+}
 
 export default LineBuilder;

package/src/core/collection/HashMap.spec.js

@@ -50,6 +50,38 @@ test("put 2 values with same hash", () => {
     expect(m.get("b")).toBe(42);
 });
 
+test("overwrite a value with the same key", () => {
+
+    const map = new HashMap({
+        keyHashFunction: returnOne,
+        keyEqualityFunction: strictEquals
+    });
+
+    map.set("x", 3);
+    map.set("x", 7);
+
+    expect(map.get("x")).toBe(7);
+
+});
+
+test("getOrCompute", () => {
+
+    const values = [1, 3, 5];
+
+    const compute = () => values.shift();
+
+    const map = new HashMap({
+        keyHashFunction: returnOne,
+        keyEqualityFunction: strictEquals
+    });
+
+    expect(map.getOrCompute("x", compute)).toBe(1);
+    expect(map.getOrCompute("x", compute)).toBe(1);
+
+    expect(map.getOrCompute("y", compute)).toBe(3);
+    expect(map.getOrCompute("y", compute)).toBe(3);
+});
+
 test("retrieval works as intended after hash map grows", () => {
     const m = new HashMap({
         keyHashFunction: passThrough,

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

@@ -171,7 +171,9 @@ List.prototype.crop = function (startIndex, endIndex) {
 };
 
 /**
- *
+ * 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
  * @param {T[]} newOutput
  */
 List.prototype.patch = function (newOutput) {
@@ -754,7 +756,7 @@ List.prototype.toJSON = function () {
 List.prototype.fromJSON = function (json, constructor) {
     this.reset();
 
-    assert.isArray(json,'json');
+    assert.isArray(json, 'json');
 
     if (typeof constructor === "function") {
         this.addAll(json.map(function (elJSON) {
@@ -780,7 +782,7 @@ List.prototype.toBinaryBuffer = function (buffer) {
     for (let i = 0; i < n; i++) {
         const item = this.data[i];
 
-        if(typeof item.toBinaryBuffer !== "function"){
+        if (typeof item.toBinaryBuffer !== "function") {
             throw new Error('item.toBinaryBuffer is not a function');
         }
 
@@ -798,7 +800,7 @@ List.prototype.fromBinaryBuffer = function (buffer, constructor) {
 
         const el = new constructor();
 
-        if(typeof el.fromBinaryBuffer !== "function"){
+        if (typeof el.fromBinaryBuffer !== "function") {
             throw new Error('item.fromBinaryBuffer is not a function');
         }
 

package/src/core/geom/Matrix4.js

@@ -4,6 +4,9 @@ const _z = new Vector3();
 const _x = new Vector3();
 const _y = new Vector3();
 
+/**
+ * @deprecated use arrays instead or mat4 from gl-matrix
+ */
 export class Matrix4 {
     /**
      *
@@ -197,7 +200,7 @@ export class Matrix4 {
         const sz = Math.hypot(this.c0, this.c1, this.c2);
 
         // if determine is negative, we need to invert one scale
-        const  det = this.determinant();
+        const det = this.determinant();
         if (det < 0) sx = -sx;
 
         position.set(

package/src/core/geom/Quaternion.js

@@ -1675,6 +1675,10 @@ class Quaternion {
         );
     }
 
+    toString() {
+        return `{ x: ${this.x}, y: ${this.y}, z: ${this.z}, w: ${this.w} }`;
+    }
+
     /**
      *
      * @param {function} random random number generator function