@woosh/meep-engine 2.49.2 → 2.49.4

package/package.json

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

package/src/core/bvh2/binary/IndexedBinaryBVH.spec.js

@@ -5,3 +5,23 @@ test("constructor does not throw", () => {
 });
 
 
+test("build a tree with a single leaf", () => {
+    const bvh = new IndexedBinaryBVH();
+
+    bvh.initialize(1);
+    bvh.writeLeaf(0, -1, -3, -7, 11, 13, 17);
+
+    bvh.unsortedBuiltIntermediate();
+
+    expect(bvh.leafNodeCount).toBe(1);
+    expect(bvh.binaryNodeCount).toBe(0);
+
+    expect(bvh.x0).toBe(-1);
+    expect(bvh.y0).toBe(-3);
+    expect(bvh.z0).toBe(-7);
+
+    expect(bvh.x1).toBe(11);
+    expect(bvh.y1).toBe(13);
+    expect(bvh.z1).toBe(17);
+
+});

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

@@ -13,6 +13,8 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
 
     collect_nodes_all(destination: ArrayLike<number>, destination_offset: number): void
 
+    node_set_aabb_primitive(node_id: number, x0: number, y0: number, z0: number, x1: number, y1: number, z1: number): void
+
     node_set_aabb(node: number, aabb: ArrayLike<number>): void
 
     node_get_aabb(node: number, aabb: ArrayLike<number>): void
@@ -37,6 +39,8 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
 
     node_get_height(node: number): number
 
+    swap_nodes(node_a_id: number, node_b_id: number): boolean
+
     release_all(): void
 
     trim(): void

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

@@ -218,3 +218,33 @@ test("node property setters/getters", () => {
 
     expect(actual_aabb).toEqual(Array.from(expected_aabb));
 });
+
+
+test("node_set_aabb_primitive", () => {
+    const bvh = new ExplicitBinaryBoundingVolumeHierarchy();
+
+    const node = bvh.allocate_node();
+
+    bvh.node_set_aabb_primitive(node, -1, -3, -5, 7, 11, 13);
+
+    const aabb = [];
+
+    bvh.node_get_aabb(node, aabb);
+
+    expect(aabb).toEqual([-1, -3, -5, 7, 11, 13]);
+});
+
+test("swap two detached nodes", () => {
+    const bvh = new ExplicitBinaryBoundingVolumeHierarchy();
+
+    const a = bvh.allocate_node();
+    const b = bvh.allocate_node();
+
+    bvh.node_set_user_data(a, 7);
+    bvh.node_set_user_data(b, 11);
+
+    bvh.swap_nodes(a, b);
+
+    expect(bvh.node_get_user_data(a)).toBe(11);
+    expect(bvh.node_get_user_data(b)).toBe(7);
+});

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

@@ -8,7 +8,12 @@ import { compute_triangle_group_aabb3 } from "../../../engine/graphics/sh3/path_
  * @param {number[]|Float32Array} positions_array
  * @param {number} [batch_size] can batch triangles in groups of up-to this many triangles per BVH leaf
  */
-export function ebvh_build_for_geometry_incremental(bvh, index_array, positions_array, batch_size = 1) {
+export function ebvh_build_for_geometry_incremental(
+    bvh,
+    index_array, positions_array,
+    batch_size = 1
+) {
+
     bvh.release_all();
     const triangle_count = index_array.length / 3;
 

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

@@ -11,8 +11,12 @@ const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
  * @param {number} destination_offset
  * @param {ExplicitBinaryBoundingVolumeHierarchy} bvh
  * @param {number} node
+ * @returns {number} number of collected elements
  */
-export function bvh_collect_user_data(destination, destination_offset, bvh, node) {
+export function bvh_collect_user_data(
+    destination, destination_offset,
+    bvh, node
+) {
 
     if (node === NULL_NODE) {
         return 0;

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

@@ -33,6 +33,8 @@ export class Cache<K, V> {
 
     remove(k: K): boolean
 
+    evictOne(): boolean
+
     clear(): void
 
     drop(): void

package/src/core/cache/Cache.js

@@ -18,7 +18,7 @@ export class Cache {
      * @param {function(value:Value):number} [valueWeigher= value=>1]
      * @param {function(Key):number} [keyHashFunction]
      * @param {function(Key, Key):boolean} [keyEqualityFunction]
-     * @param {number} capacity initial capacity for the cache, helps prevent early resizing
+     * @param {number} [capacity] initial capacity for the cache, helps prevent early resizing
      * @constructor
      */
     constructor({

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

@@ -18,6 +18,19 @@ test("elements beyond capacity are evicted", () => {
 
 });
 
+test("trying to insert an element into the cache that's larger than the cache capacity should result in the item not being inserted", () => {
+    const cache = new Cache({
+        maxWeight: 1,
+        keyWeigher(key) {
+            return key;
+        }
+    });
+
+    cache.put(2, "hello");
+
+    expect(cache.contains(2)).toBe(false);
+});
+
 test("removeListener is called when element is evicted", () => {
 
     const removeListener = jest.fn();
@@ -140,3 +153,9 @@ test("clear with a single entry", () => {
     expect(cache.contains("x")).toBe(false);
 
 });
+
+test("calling 'evictOne' on empty cache should return false", () => {
+    const cache = new Cache();
+
+    expect(cache.evictOne()).toBe(false);
+});

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

@@ -0,0 +1,18 @@
+export declare class LoadingCache<K,V>{
+    constructor(options:{
+        maxWeight?: number,
+        keyWeigher?: (key: K) => number,
+        valueWeigher?: (value: V) => number,
+        keyHashFunction?: (key: K) => number,
+        keyEqualityFunction?: (a: K, b: K) => boolean,
+        capacity?: number,
+        timeToLive?:number,
+        load:(key:K)=> Promise<V>
+    })
+
+    invalidate(key:K):void
+
+    clear():void
+
+    get(key:K):Promise<V>
+}

package/src/core/cache/LoadingCache.js

@@ -0,0 +1,115 @@
+//
+
+import { Cache } from "./Cache.js";
+
+/**
+ * @template {V}
+ */
+class Record {
+    /**
+     *
+     * @param {V} value
+     * @param {number} time
+     */
+    constructor(value, time) {
+        this.value = value;
+        this.time = time;
+    }
+}
+
+const DEFAULT_TIME_TO_LIVE = 10;
+
+/**
+ * @template K,V
+ */
+export class LoadingCache {
+    /**
+     * @type {Cache<K,Record<Promise<V>>>}
+     */
+    #internal
+    /**
+     * In seconds
+     * @type {number}
+     */
+    #timeToLive = DEFAULT_TIME_TO_LIVE;
+
+    /**
+     * @type {function(key:K):Promise<V>}
+     */
+    #load
+
+    /**
+     * @see {@link Cache} for more details on what each parameter means
+     * @param maxWeight
+     * @param keyWeigher
+     * @param valueWeigher
+     * @param keyHashFunction
+     * @param keyEqualityFunction
+     * @param capacity
+     * @param {number} [timeToLive] in seconds
+     * @param load
+     */
+    constructor({
+                    maxWeight,
+                    keyWeigher,
+                    valueWeigher,
+                    keyHashFunction,
+                    keyEqualityFunction,
+                    capacity,
+                    timeToLive = DEFAULT_TIME_TO_LIVE,
+                    load
+                }) {
+
+        this.#internal = new Cache({
+            maxWeight,
+            keyWeigher,
+            valueWeigher,
+            keyHashFunction,
+            keyEqualityFunction,
+            capacity,
+        });
+
+        this.#timeToLive = timeToLive;
+        this.#load = load;
+    }
+
+    /**
+     *
+     * @param {K} key
+     */
+    invalidate(key) {
+        this.#internal.remove(key);
+    }
+
+    /**
+     *
+     */
+    clear() {
+        this.#internal.clear();
+    }
+
+    /**
+     *
+     * @param {K} key
+     * @return {Promise<V>}
+     */
+    async get(key) {
+        const currentTime = performance.now() * 1e-3;
+
+        let record = this.#internal.get(key);
+
+        if (record === null || (record.time + this.#timeToLive) < currentTime) {
+
+            // missing or stale record
+            const promise = this.#load(key);
+
+            record = new Record(promise, currentTime);
+
+            this.#internal.put(key, record);
+
+        }
+
+
+        return record.value;
+    }
+}

package/src/core/codegen/LineBuilder.js

@@ -39,6 +39,14 @@ class LineBuilder {
      */
     indentSpaces = DEFAULT_INDENT_SPACES;
 
+    /**
+     * Number of lines
+     * @return {number}
+     */
+    get count() {
+        return this.lines.length;
+    }
+
     /**
      *
      * @return {boolean}
@@ -115,7 +123,6 @@ class LineBuilder {
     clear() {
         this.lines = [];
         this.indentation = 0;
-        this.indentSpaces = DEFAULT_INDENT_SPACES;
     }
 
     /**

package/src/core/codegen/LineBuilder.spec.js

@@ -5,3 +5,37 @@ test("Empty builder should produce empty string", () => {
 
     expect(b.build()).toEqual("");
 });
+
+test("build simple indented fragment", () => {
+    const b = new LineBuilder();
+
+    b.indentSpaces = 1;
+
+    b.add('a');
+    b.indent();
+    b.add('b');
+    b.dedent();
+    b.add('c');
+
+    expect(b.build()).toEqual('a\n b\nc');
+});
+
+test("adding another line builder copies lines correctly", () => {
+    const a = new LineBuilder();
+
+    const b = new LineBuilder();
+
+    b.add('a');
+
+    a.addLines(b);
+
+    expect(a.build()).toEqual('a');
+});
+
+test("fromText parses correct number of lines", () => {
+
+    const builder = LineBuilder.fromText('a\nb');
+
+    expect(builder.count).toBe(2);
+
+});

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

@@ -12,7 +12,12 @@ const stack = [];
  * @param {function(T[],number, number):*} [swap_operator]
  * @param {*} [swap_context]
  */
-export function arrayQuickSort(data, score_function, score_function_context, start, end, swap_operator = arraySwapElements, swap_context = undefined) {
+export function arrayQuickSort(
+    data,
+    score_function, score_function_context,
+    start, end,
+    swap_operator = arraySwapElements, swap_context = undefined
+) {
     if (start >= end) {
         // section of 0 size, nothing to sort
         return;
@@ -79,7 +84,11 @@ export function arrayQuickSort(data, score_function, score_function_context, sta
  * @param {number} start
  * @param {number} end
  */
-export function array_quick_sort_by_comparator(data, compare_function, compare_function_context, start, end) {
+export function array_quick_sort_by_comparator(
+    data,
+    compare_function, compare_function_context,
+    start, end
+) {
     if (start >= end) {
         // section of 0 size, nothing to sort
         return;

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

@@ -5,7 +5,12 @@
  * @param {number} [end_index] last index to be included in the search
  * @return {boolean}
  */
-export function array_contains_duplicates(source, start_index = 0, end_index = source.length - 1) {
+export function array_contains_duplicates(
+    source,
+    start_index = 0,
+    end_index = source.length - 1
+) {
+
     for (let k = start_index; k <= end_index; k++) {
 
         const element = source[k];

package/src/core/collection/array/typed/is_typed_array_equals.js

@@ -3,11 +3,16 @@ import { isArrayEqualStrict } from "../isArrayEqualStrict.js";
 
 /**
  *
- * @param {Uint8Array} a
- * @param {Uint8Array} b
+ * @param {Uint8Array|Uint32Array} a
+ * @param {Uint8Array|Uint32Array} b
  * @returns {boolean}
  */
 export function is_typed_array_equals(a, b) {
+    if (a === b) {
+        // quick shortcut
+        return true;
+    }
+
     const a_length = a.length;
     const b_length = b.length;
 
@@ -26,13 +31,15 @@ export function is_typed_array_equals(a, b) {
         return false;
     }
 
-    const bytes_per_element = a.constructor.BYTES_PER_ELEMENT;
+    const a_constructor = a.constructor;
+    const b_constructor = b.constructor;
 
-    if (bytes_per_element !== b.constructor.BYTES_PER_ELEMENT) {
+    if (a_constructor !== b_constructor) {
         // incompatible constructors
         return false;
     }
 
+
     const a_buffer = a.buffer;
     const b_buffer = b.buffer;
 
@@ -45,6 +52,8 @@ export function is_typed_array_equals(a, b) {
     let a_proxy = a;
     let b_proxy = b;
 
+    const bytes_per_element = a_constructor.BYTES_PER_ELEMENT;
+
     if (bytes_per_element < 4 && byte_length % 4 === 0) {
         // 4 byte alignment, can use uint32
         a_proxy = new Uint32Array(a_buffer, a.byteOffset, byte_length / 4);

package/src/core/collection/array/typed/is_typed_array_equals.spec.js

@@ -0,0 +1,71 @@
+import { is_typed_array_equals } from "./is_typed_array_equals.js";
+
+test("small uint32 arrays", () => {
+    expect(is_typed_array_equals(
+        new Uint32Array(0),
+        new Uint32Array(0)
+    )).toBe(true);
+
+    expect(is_typed_array_equals(
+        new Uint32Array([1, 3, 5]),
+        new Uint32Array([1, 3, 5])
+    )).toBe(true);
+
+    expect(is_typed_array_equals(
+        new Uint32Array([7, 3]),
+        new Uint32Array([1, 3])
+    )).toBe(false);
+
+    expect(is_typed_array_equals(
+        new Uint32Array([1, 3]),
+        new Uint32Array([7, 3])
+    )).toBe(false);
+
+    expect(is_typed_array_equals(
+        new Uint32Array([1, 7]),
+        new Uint32Array([1, 3])
+    )).toBe(false);
+
+    expect(is_typed_array_equals(
+        new Uint32Array([1, 3]),
+        new Uint32Array([1, 7])
+    )).toBe(false);
+
+    expect(is_typed_array_equals(
+        new Uint32Array([1, 3]),
+        new Uint32Array([1, 3, 7])
+    )).toBe(false);
+
+    expect(is_typed_array_equals(
+        new Uint32Array([1, 3, 7]),
+        new Uint32Array([1, 3])
+    )).toBe(false);
+
+});
+
+test("large uin32 array", () => {
+    expect(is_typed_array_equals(
+        new Uint32Array(1024),
+        new Uint32Array(1024),
+    )).toBe(true);
+
+    expect(is_typed_array_equals(
+        new Uint32Array(1024),
+        new Uint32Array(1023),
+    )).toBe(false);
+
+    expect(is_typed_array_equals(
+        new Uint32Array(1023),
+        new Uint32Array(1024),
+    )).toBe(false);
+
+    const a = new Uint32Array(1024);
+    const b = new Uint32Array(1024);
+
+    a[127] = 1;
+
+    expect(is_typed_array_equals(
+        a,
+        b,
+    )).toBe(false);
+});

package/src/core/collection/table/RowFirstTable.js

@@ -98,7 +98,7 @@ RowFirstTable.prototype.hash = function () {
 
     const byteLength = this.data.byteLength;
 
-    const tap_count = 32;
+    const tap_count = 31;
 
     const step_size = max2(
         Math.floor(byteLength / (tap_count * 4)),

package/src/core/collection/table/RowFirstTable.spec.js

@@ -285,3 +285,39 @@ test('reverse_rows empty', () => {
 
     expect(a.length).toBe(0);
 });
+
+test("hash on an empty ", () => {
+    const table = new RowFirstTable(new RowFirstTableSpec([BinaryDataType.Uint8]));
+
+    expect(() => table.hash()).not.toThrow();
+    expect(table.hash()).toEqual(table.hash());
+    expect(typeof table.hash() === "number").toBe(true);
+    expect(Number.isInteger(table.hash())).toBe(true);
+});
+
+test("equals method", () => {
+    const a = new RowFirstTable(new RowFirstTableSpec([BinaryDataType.Uint8]));
+    const b = new RowFirstTable(new RowFirstTableSpec([BinaryDataType.Uint8]));
+
+    expect(a.equals(b)).toBe(true);
+
+    a.addRow([1]);
+
+    expect(a.equals(b)).toBe(false);
+    expect(b.equals(a)).toBe(false);
+
+    b.addRow([3]);
+
+    expect(a.equals(b)).toBe(false);
+});
+
+test("toRowArray", () => {
+    const a = new RowFirstTable(new RowFirstTableSpec([BinaryDataType.Uint8, BinaryDataType.Float64]));
+    a.addRow([3, 7.11]);
+    a.addRow([5, 13.17]);
+
+    expect(a.toRowArray()).toEqual([
+        [3, 7.11],
+        [5, 13.17],
+    ]);
+});

package/src/core/collection/table/RowFirstTableSpec.js

@@ -9,6 +9,7 @@ import { computeStringHash } from "../../primitives/strings/computeStringHash.js
 import { isArrayEqualStrict } from "../array/isArrayEqualStrict.js";
 import { BinaryDataType } from "../../binary/type/BinaryDataType.js";
 import { DataTypeByteSizes } from "../../binary/type/DataTypeByteSizes.js";
+import { assert } from "../../assert.js";
 
 /**
  * @readonly
@@ -158,6 +159,8 @@ function genCellReader(type, offset, endianType = EndianType.BigEndian) {
  * @constructor
  */
 export function RowFirstTableSpec(types, endianType = EndianType.BigEndian) {
+    assert.isArray(types, 'types');
+
     const numTypes = types.length;
 
     /**

package/src/core/color/hsv2rgb.js

@@ -10,22 +10,27 @@ import { float2uint8 } from "../binary/float2uint8.js";
  */
 export function hsv2rgb(h, s, v) {
 
-    let _h = h % 1;
+    let _h = h;
 
     if (_h < 0) {
-        _h = h + 1;
+        _h = _h + Math.ceil(Math.abs(_h));
     }
 
+    _h = _h % 1;
+
     const _s = clamp01(s);
     const _v = clamp01(v);
 
     let r, g, b, i, f, p, q, t;
 
-    i = Math.floor(h * 6);
+    i = Math.floor(_h * 6);
+
     f = _h * 6 - i;
+
     p = _v * (1 - _s);
     q = _v * (1 - f * _s);
     t = _v * (1 - (1 - f) * _s);
+
     switch (i % 6) {
         case 0:
             r = _v, g = t, b = p;

package/src/core/color/hsv2rgb.spec.js

@@ -0,0 +1,43 @@
+import { hsv2rgb } from "./hsv2rgb.js";
+
+function validate_element(number) {
+    expect(typeof number).toBe('number');
+    expect(Number.isNaN(number)).toBe(false);
+
+    expect(number).toBeLessThanOrEqual(255);
+    expect(number).toBeGreaterThanOrEqual(0);
+}
+
+function validate_rgb(rgb) {
+    expect(rgb).not.toBeUndefined();
+    expect(rgb).not.toBeNull();
+    expect(typeof rgb).toBe('object');
+
+    validate_element(rgb.r);
+    validate_element(rgb.g);
+    validate_element(rgb.b);
+}
+
+test("sanity test", () => {
+
+    validate_rgb(hsv2rgb(0, 0, 0));
+    validate_rgb(hsv2rgb(0, 0, 1));
+    validate_rgb(hsv2rgb(0, 1, 0));
+    validate_rgb(hsv2rgb(0, 1, 1));
+    validate_rgb(hsv2rgb(1, 0, 0));
+    validate_rgb(hsv2rgb(1, 0, 1));
+    validate_rgb(hsv2rgb(1, 1, 0));
+    validate_rgb(hsv2rgb(1, 1, 1));
+
+    validate_rgb(hsv2rgb(0.5, 0.5, 0.5));
+
+    validate_rgb(hsv2rgb(0.1, 0.5, 0.5));
+    validate_rgb(hsv2rgb(0.2, 0.5, 0.5));
+    validate_rgb(hsv2rgb(0.3, 0.5, 0.5));
+    validate_rgb(hsv2rgb(0.4, 0.5, 0.5));
+    validate_rgb(hsv2rgb(0.6, 0.5, 0.5));
+    validate_rgb(hsv2rgb(0.7, 0.5, 0.5));
+    validate_rgb(hsv2rgb(0.8, 0.5, 0.5));
+    validate_rgb(hsv2rgb(0.9, 0.5, 0.5));
+
+});

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

@@ -7,7 +7,8 @@ import { aabb3_intersects_ray } from "./aabb3_intersects_ray.js";
  * @returns {boolean}
  */
 export function aabb3_array_intersects_ray_array(aabb, ray) {
-    return aabb3_intersects_ray(aabb[0], aabb[1], aabb[2], aabb[3], aabb[4], aabb[5],
+    return aabb3_intersects_ray(
+        aabb[0], aabb[1], aabb[2], aabb[3], aabb[4], aabb[5],
         ray[0], ray[1], ray[2],
         ray[3], ray[4], ray[5]
     );