@woosh/meep-engine 2.55.0 → 2.56.0

package/editor/view/node-graph/PortView.js

@@ -1,10 +1,10 @@
 import View from "../../../src/view/View.js";
 import { PortDirection } from "../../../src/core/model/node-graph/node/PortDirection.js";
-import { camelToKebab } from "../../../src/core/primitives/strings/StringUtils.js";
 import LabelView from "../../../src/view/common/LabelView.js";
 import EmptyView from "../../../src/view/elements/EmptyView.js";
 import { Color } from "../../../src/core/color/Color.js";
 import { objectKeyByValue } from "../../../src/core/model/object/objectKeyByValue.js";
+import { string_format_camel_to_kebab } from "../../../src/core/primitives/strings/string_format_camel_to_kebab.js";
 
 const DEFAULT_TYPE_COLOR = new Color(1, 1, 1);
 
@@ -35,7 +35,7 @@ export class PortView extends View {
 
         this.addClass(`direction-${objectKeyByValue(PortDirection, port.direction).toLocaleLowerCase()}`);
 
-        this.addClass(`data-type-${camelToKebab(port.dataType.name)}`);
+        this.addClass(`data-type-${string_format_camel_to_kebab(port.dataType.name)}`);
 
         //add port name label
         const vName = new LabelView(port.name, {

package/package.json

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

package/src/core/binary/BinaryBuffer.js

@@ -52,7 +52,8 @@ export class BinaryBuffer {
     position = 0;
 
     /**
-     * @deprecated
+     * Same as {@link capacity}
+     * @deprecated use {@link position} or {@link capacity} instead
      * @type {number}
      */
     length = 0;

package/src/core/cache/LoadingCache.js

@@ -1,6 +1,7 @@
 //
 
 import { Cache } from "./Cache.js";
+import { current_time_in_seconds } from "../time/current_time_in_seconds.js";
 
 /**
  * @template R
@@ -18,13 +19,16 @@ class Record {
     }
 }
 
-function current_time_in_seconds() {
-    return performance.now() * 1e-3;
-}
-
-const DEFAULT_TIME_TO_LIVE = 10;
+/**
+ * In seconds
+ * @readonly
+ * @type {number}
+ */
+const DEFAULT_TIME_TO_LIVE = 300; // 5 Minutes
 
 /**
+ * Asynchronous cache capable of resolving its own values by keys
+ * Modelled on Guava's LoadingCache concept
  * @template K,V
  */
 export class LoadingCache {
@@ -33,6 +37,7 @@ export class LoadingCache {
      */
     #internal
     /**
+     * Time until records are marked as invalid, invalid records are not served back and trigger re-loading of the value
      * In seconds
      * @type {number}
      */

package/src/core/collection/array/array_remove_element.js

@@ -1,4 +1,7 @@
+import { array_remove_first } from "./array_remove_first.js";
+
 /**
+ * @deprecated
  * @template T
  * @param {T[]} array
  * @param {number} start_index
@@ -7,13 +10,7 @@
  * @return {boolean}
  */
 export function array_remove_element(array, start_index, end_index, element) {
-    for (let i = start_index; i < end_index; i++) {
-        if (array[i] === element) {
-            array.splice(i, 1);
-
-            return true;
-        }
-    }
+    console.warn('deprecated, use array_remove_first instead');
 
-    return false;
-}
+    array_remove_first(array, element, start_index, end_index - start_index);
+}

package/src/core/collection/array/array_remove_first.js

@@ -1,15 +1,22 @@
 /**
+ * Remove first occurrence of element from the array
  * @template T
  * @param {T[]} array
  * @param {T} element
- * @return {boolean}
+ * @param {number} [start_index]
+ * @param {number} [length]
+ * @return {boolean} true if element was removed, false if it was not found
  */
-export function array_remove_first(array, element){
-    const i = array.indexOf(element);
+export function array_remove_first(array, element, start_index = 0, length = array.length) {
 
-    if(i !== -1){
-        array.splice(i,1);
-        return true;
+    const end_index = start_index + length;
+
+    for (let i = start_index; i < end_index; i++) {
+        if (array[i] === element) {
+            array.splice(i, 1);
+
+            return true;
+        }
     }
 
     return false;

package/src/core/collection/array/array_remove_first.spec.js

@@ -0,0 +1,39 @@
+import { array_remove_first } from "./array_remove_first.js";
+
+test("basics", () => {
+
+    expect(array_remove_first([], 1)).toBe(false);
+    expect(array_remove_first([2], 1)).toBe(false);
+    expect(array_remove_first([2, 3], 1)).toBe(false);
+
+    let array = [1];
+
+    expect(array_remove_first(array, 1)).toBe(true);
+
+    expect(array).toEqual([]);
+
+    array = [1, 1];
+
+    expect(array_remove_first(array, 1)).toBe(true);
+
+    expect(array).toEqual([1]);
+
+    array = [2, 1];
+
+    expect(array_remove_first(array, 1)).toBe(true);
+
+    expect(array).toEqual([2]);
+
+    array = [1, 2];
+
+    expect(array_remove_first(array, 1)).toBe(true);
+
+    expect(array).toEqual([2]);
+
+    array = [1, 2, 1];
+
+    expect(array_remove_first(array, 1)).toBe(true);
+
+    expect(array).toEqual([2, 1]);
+
+});

package/src/core/collection/array/binarySearchHighIndex.spec.js

@@ -1,50 +1,51 @@
 import { binarySearchHighIndex } from "./binarySearchHighIndex.js";
-import { compareNumbersAscending } from "../../function/Functions.js";
+
+import { number_compare_ascending } from "../../primitives/numbers/number_compare_ascending.js";
 
 test('exact match single element 1', () => {
     expect(
-        binarySearchHighIndex([1], 1, compareNumbersAscending, 0, 0)
+        binarySearchHighIndex([1], 1, number_compare_ascending, 0, 0)
     ).toBe(0);
 });
 
 test('exact match single element 0', () => {
     expect(
-        binarySearchHighIndex([0], 0, compareNumbersAscending, 0, 0)
+        binarySearchHighIndex([0], 0, number_compare_ascending, 0, 0)
     ).toBe(0);
 });
 
 test('exact match single element -1', () => {
     expect(
-        binarySearchHighIndex([-1], -1, compareNumbersAscending, 0, 0)
+        binarySearchHighIndex([-1], -1, number_compare_ascending, 0, 0)
     ).toBe(0);
 });
 
 test('0 -> 0,0', () => {
     expect(
-        binarySearchHighIndex([0, 0], 0, compareNumbersAscending, 0, 1)
+        binarySearchHighIndex([0, 0], 0, number_compare_ascending, 0, 1)
     ).toBe(0);
 });
 
 test('0 -> 0,1', () => {
     expect(
-        binarySearchHighIndex([0, 1], 0, compareNumbersAscending, 0, 1)
+        binarySearchHighIndex([0, 1], 0, number_compare_ascending, 0, 1)
     ).toBe(0);
 });
 
 test('1 -> 1,1', () => {
     expect(
-        binarySearchHighIndex([1, 1], 1, compareNumbersAscending, 0, 1)
+        binarySearchHighIndex([1, 1], 1, number_compare_ascending, 0, 1)
     ).toBe(0);
 });
 
 test('0 -> 1,2', () => {
     expect(
-        binarySearchHighIndex([1, 2], 0, compareNumbersAscending, 0, 1)
+        binarySearchHighIndex([1, 2], 0, number_compare_ascending, 0, 1)
     ).toBe(0);
 });
 
 test('1.5 -> 1,2', () => {
     expect(
-        binarySearchHighIndex([1, 2], 1.5, compareNumbersAscending, 0, 1)
+        binarySearchHighIndex([1, 2], 1.5, number_compare_ascending, 0, 1)
     ).toBe(1);
 });

package/src/core/collection/heap/Uin32Heap.spec.js

@@ -1,4 +1,5 @@
 import { Uint32Heap } from "./Uint32Heap.js";
+import { seededRandom } from "../../math/random/seededRandom.js";
 
 test('initial capacity setting via constructor', () => {
     const heap = new Uint32Heap(3);
@@ -93,6 +94,9 @@ test("update_score", () => {
 
     expect(heap.pop_min()).toEqual(7);
     expect(heap.pop_min()).toEqual(1);
+
+    // expect request to a missing element to throw
+    expect(() => heap.update_score(7, 0)).toThrow();
 });
 
 test("get_score", () => {
@@ -121,3 +125,35 @@ test("insert_or_update", () => {
     expect(heap.get_score(7)).toBe(17);
 
 });
+
+
+test.skip("performance 1,000,000 random element fill / drain", () => {
+
+    const random = seededRandom(7);
+
+    const COUNT = 1000000;
+
+    const random_values = new Float32Array(COUNT);
+
+    for (let i = 0; i < COUNT; i++) {
+        random_values[i] = random();
+    }
+
+    const heap = new Uint32Heap();
+
+    const t0 = performance.now();
+    for (let i = 0; i < COUNT; i++) {
+        heap.insert(i, random_values[i]);
+    }
+    const t1 = performance.now();
+
+    for (let i = 0; i < COUNT; i++) {
+        heap.pop_min();
+    }
+    const t2 = performance.now();
+
+    const fill_time = t1 - t0;
+    const drain_time = t2 - t1;
+
+    console.log(`Fill took ${fill_time}ms (${COUNT / (fill_time * 0.001)} elements per second), drain took ${drain_time}ms (${COUNT / (drain_time * 0.001)} elements per second)`);
+});

package/src/core/collection/heap/Uint32Heap.js

@@ -87,10 +87,10 @@ export class Uint32Heap {
     __capacity_grow() {
         const old_capacity = this.__capacity;
 
-        const new_capacity = max2(
+        const new_capacity = Math.ceil(max2(
             old_capacity * RESIZE_GROW_FACTOR,
             old_capacity + RESIZE_GROW_MIN_COUNT
-        );
+        ));
 
         assert.greaterThan(new_capacity, old_capacity, 'invalid growth');
 
@@ -117,7 +117,10 @@ export class Uint32Heap {
     compare(a, b) {
         const float32 = this.__data_float32;
 
-        return float32[a * 2] < float32[b * 2];
+        const a2 = a << 1; // same as a*2
+        const b2 = b << 1; // same as b*2
+
+        return float32[a2] < float32[b2];
     }
 
     /**
@@ -127,8 +130,9 @@ export class Uint32Heap {
      * @param {number} j element index
      */
     swap(i, j) {
-        const i2 = i * 2;
-        const j2 = j * 2;
+        // fast multiplication by 2
+        const i2 = i << 1; // same as i*2
+        const j2 = j << 1; // same as j*2
 
         const uint32 = this.__data_uint32;
 
@@ -385,6 +389,7 @@ export class Uint32Heap {
     insert(id, score) {
         assert.isNonNegativeInteger(id, 'value');
         assert.lessThanOrEqual(id, UINT32_MAX - 1, 'must be less than or equal to (2^32 - 2)');
+        assert.isNumber(score, 'score');
 
         if (this.__size >= this.__capacity) {
             // need to re-allocate

package/src/core/function/FunctionCompiler.js

@@ -4,9 +4,9 @@ import { isArrayEqualStrict } from "../collection/array/isArrayEqualStrict.js";
 import { invokeObjectEquals } from "../model/object/invokeObjectEquals.js";
 import { invokeObjectHash } from "../model/object/invokeObjectHash.js";
 import { computeStringHash } from "../primitives/strings/computeStringHash.js";
-import { computeUTF8StringByteSize } from "../primitives/strings/StringUtils.js";
 import { computeHashArray } from "../collection/array/computeHashArray.js";
 import { computeHashIntegerArray } from "../collection/array/computeHashIntegerArray.js";
+import { string_compute_byte_size } from "../primitives/strings/string_compute_byte_size.js";
 
 /**
  * Hash is an integer value, so this is an invalid value for a computed hash
@@ -62,17 +62,17 @@ class FunctionDefinition {
      */
     computeByteSize() {
 
-        let result = computeUTF8StringByteSize(this.body);
+        let result = string_compute_byte_size(this.body);
 
         if (this.name !== undefined) {
-            result += computeUTF8StringByteSize(this.name);
+            result += string_compute_byte_size(this.name);
         }
 
         const n = this.args.length;
         for (let i = 0; i < n; i++) {
             const arg = this.args[i];
 
-            result += computeUTF8StringByteSize(arg);
+            result += string_compute_byte_size(arg);
         }
 
         return result;

package/src/core/function/Functions.js

@@ -101,22 +101,3 @@ export function chainFunctions(...processes) {
 }
 
 
-/**
- *
- * @param {number} a
- * @param {number} b
- * @return {number}
- */
-export function compareNumbersAscending(a, b) {
-    return a - b;
-}
-
-/**
- *
- * @param {number} a
- * @param {number} b
- * @return {number}
- */
-export function compareNumbersDescending(a, b) {
-    return b - a;
-}

package/src/core/geom/3d/SurfacePoint3.js

@@ -6,26 +6,25 @@ import { assert } from "../../assert.js";
  * Used for representing points on a 3D surface. Used for raycasting contacts
  */
 export class SurfacePoint3 {
-    constructor() {
-        /**
-         * @readonly
-         * @type {Vector3}
-         */
-        this.normal = new Vector3(0, 1, 0);
-
-        /**
-         * @readonly
-         * @type {Vector3}
-         */
-        this.position = new Vector3(0, 0, 0);
-
-        /**
-         * Primitive index, such as triangle/point/line from the source geometry
-         * optional
-         * @type {number}
-         */
-        this.index = -1;
-    }
+
+    /**
+     * @readonly
+     * @type {Vector3}
+     */
+    normal = new Vector3(0, 1, 0);
+
+    /**
+     * @readonly
+     * @type {Vector3}
+     */
+    position = new Vector3(0, 0, 0);
+
+    /**
+     * Primitive index, such as triangle/point/line from the source geometry
+     * optional
+     * @type {number}
+     */
+    index = -1;
 
     get 0() {
         return this.position.x;
@@ -129,6 +128,17 @@ export class SurfacePoint3 {
         this.normal.writeToArray(array, offset + 3);
     }
 
+    /**
+     *
+     * @param {SurfacePoint3} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return this.index === other.index
+            && this.position.equals(other.position)
+            && this.normal.equals(other.normal);
+    }
+
     /**
      *
      * @param {SurfacePoint3} other

package/src/core/geom/3d/SurfacePoint3.spec.js

@@ -0,0 +1,116 @@
+import { SurfacePoint3 } from "./SurfacePoint3.js";
+import { MATRIX_4_IDENTITY } from "./matrix/MATRIX_4_IDENTITY.js";
+
+
+test("equals", () => {
+
+    const a = new SurfacePoint3();
+
+    a.position.set(1, 3, 5);
+    a.normal.set(7, 11, 13);
+    a.index = 97;
+
+    const b = new SurfacePoint3();
+
+    expect(a.equals(b)).toBe(false);
+
+    b.index = 97;
+
+    expect(a.equals(b)).toBe(false);
+
+    b.position.set(1, 3, 5);
+
+    expect(a.equals(b)).toBe(false);
+
+    b.normal.set(7, 11, 13);
+
+    expect(a.equals(b)).toBe(true);
+
+    b.index = 91;
+
+    expect(a.equals(b)).toBe(false);
+});
+
+test("copy", () => {
+    const a = new SurfacePoint3();
+
+    a.position.set(1, 3, 5);
+    a.normal.set(7, 11, 13);
+    a.index = 97;
+
+    const b = new SurfacePoint3();
+
+    b.copy(a);
+
+    expect(b.position.x).toBe(1);
+    expect(b.position.y).toBe(3);
+    expect(b.position.z).toBe(5);
+
+    expect(b.normal.x).toBe(7);
+    expect(b.normal.y).toBe(11);
+    expect(b.normal.z).toBe(13);
+
+    expect(b.index).toBe(97);
+});
+
+test("array-style getters", () => {
+
+    const point = new SurfacePoint3();
+
+    point.position.set(1, 3, 5);
+    point.normal.set(7, 11, 13);
+
+    expect(point[0]).toBe(1);
+    expect(point[1]).toBe(3);
+    expect(point[2]).toBe(5);
+
+    expect(point[3]).toBe(7);
+    expect(point[4]).toBe(11);
+    expect(point[5]).toBe(13);
+
+});
+
+test("toArray", () => {
+
+    const point = new SurfacePoint3();
+
+    point.position.set(1, 3, 5);
+    point.normal.set(7, 11, 13);
+
+    const array = [99];
+
+    point.toArray(array, 1);
+
+    expect(array).toEqual([99, 1, 3, 5, 7, 11, 13]);
+});
+
+test("fromArray", () => {
+    const point = new SurfacePoint3();
+
+    point.fromArray([99, 1, 3, 5, 7, 11, 13], 1);
+
+    expect(point.position.x).toBe(1);
+    expect(point.position.y).toBe(3);
+    expect(point.position.z).toBe(5);
+
+    expect(point.normal.x).toBe(7);
+    expect(point.normal.y).toBe(11);
+    expect(point.normal.z).toBe(13);
+
+});
+
+test("applyMatrix4 with identity matrix", () => {
+
+    const original = new SurfacePoint3();
+
+    original.position.set(1, 3, 5);
+    original.normal.set(7, 11, 13);
+
+    original.normal.normalize();
+
+    const transformed = original.clone();
+
+    transformed.applyMatrix4(MATRIX_4_IDENTITY);
+
+    expect(transformed.equals(original)).toBe(true);
+});

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

@@ -15,7 +15,7 @@ import { aabb3_compute_surface_area } from "./aabb3_compute_surface_area.js";
 import { aabb3_intersects_frustum_array } from "./aabb3_intersects_frustum_array.js";
 import { aabb3_matrix4_project } from "./aabb3_matrix4_project.js";
 import { aabb3_signed_distance_sqr_to_point } from "./aabb3_signed_distance_sqr_to_point.js";
-import { aabb3_array_contains_point } from "./aabb3_array_contains_point.js";
+import { aabb3_array_intersects_point } from "./aabb3_array_intersects_point.js";
 
 /**
  * Axis-Aligned bounding box in 3D
@@ -106,14 +106,14 @@ export class AABB3 {
     }
 
     /**
-     * @deprecated use {@link aabb3_array_contains_point} directly
+     * @deprecated use {@link aabb3_array_intersects_point} directly
      * @param {number} x
      * @param {number} y
      * @param {number} z
      * @returns {boolean}
      */
     containsPoint(x, y, z) {
-        return aabb3_array_contains_point(this, x, y, z);
+        return aabb3_array_intersects_point(this, x, y, z);
     }
 
     /**
@@ -251,6 +251,8 @@ export class AABB3 {
      * @param {Number} z1
      */
     setBoundsUnordered(x0, y0, z0, x1, y1, z1) {
+
+        // sort bound coordinates
         let _x0, _y0, _z0, _x1, _y1, _z1;
         if (x0 < x1) {
             _x0 = x0;
@@ -273,7 +275,10 @@ export class AABB3 {
             _z0 = z1;
             _z1 = z0;
         }
+
+        // write sorted
         this.setBounds(_x0, _y0, _z0, _x1, _y1, _z1);
+
     }
 
     setNegativelyInfiniteBounds() {
@@ -293,12 +298,8 @@ export class AABB3 {
      */
     distanceToPoint2(x, y, z) {
         return aabb3_signed_distance_sqr_to_point(
-            this.x0,
-            this.y0,
-            this.z0,
-            this.x1,
-            this.y1,
-            this.z1,
+            this.x0, this.y0, this.z0,
+            this.x1, this.y1, this.z1,
             x, y, z
         );
     }

package/src/core/geom/3d/aabb/{aabb3_array_contains_point.js → aabb3_array_intersects_point.js}

@@ -8,7 +8,10 @@
  * @param {number} z
  * @return {boolean}
  */
-export function aabb3_array_contains_point(aabb, x, y, z) {
+export function aabb3_array_intersects_point(
+    aabb,
+    x, y, z
+) {
     return x >= aabb[0]
         && x <= aabb[3]
         && y >= aabb[1]

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

@@ -1,10 +1,34 @@
+import { assert } from "../../../assert.js";
+
 /**
  *
  * @param {number[]|Float32Array|Float64Array} result
  * @param {{x:number,y:number,z:number}} min
  * @param {{x:number,y:number,z:number}} max
  */
-export function aabb3_from_min_max(result, min, max) {
+export function aabb3_from_min_max(
+    result,
+    min, max
+) {
+    // read out bounds
+    const x0 = min.x;
+    const y0 = min.y;
+    const z0 = min.z;
+
+    const x1 = max.x;
+    const y1 = max.y;
+    const z1 = max.z;
+
+    // validate bounds
+    assert.notNaN(x0, 'x0');
+    assert.notNaN(y0, 'y0');
+    assert.notNaN(z0, 'z0');
+
+    assert.notNaN(x1, 'x1');
+    assert.notNaN(y1, 'y1');
+    assert.notNaN(z1, 'z1');
+
+    // marshal to output
     result[0] = min.x;
     result[1] = min.y;
     result[2] = min.z;