@woosh/meep-engine 2.49.9 → 2.50.1

package/editor/actions/concrete/ArrayCopyAction.js

@@ -1,5 +1,5 @@
 import { Action } from "../../../src/core/process/undo/Action.js";
-import { array_copy } from "../../../src/core/collection/array/copyArray.js";
+import { array_copy } from "../../../src/core/collection/array/array_copy.js";
 
 export class ArrayCopyAction extends Action {
     /**

package/package.json

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

package/src/core/binary/BinaryBuffer.js

@@ -3,7 +3,7 @@
  * @enum {boolean}
  */
 import { assert } from "../assert.js";
-import { array_copy } from "../collection/array/copyArray.js";
+import { array_copy } from "../collection/array/array_copy.js";
 
 /**
  *

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

@@ -114,6 +114,19 @@ test('string read write consistency, complex', () => {
     expect(actual).toEqual(expected);
 });
 
+test('string read write consistency, 4byte characters', () => {
+    const buffer = new BinaryBuffer();
+
+    const expected = "𓀀𓀁𓂀𓂇𓃵";
+    buffer.writeUTF8String(expected);
+
+    buffer.position = 0;
+
+    const actual = buffer.readUTF8String();
+
+    expect(actual).toEqual(expected);
+});
+
 test('string read write consistency, russian', () => {
     const buffer = new BinaryBuffer();
 
@@ -166,6 +179,64 @@ test('string read write, multiple', () => {
     expect(buffer.readUTF8String()).toBe('b');
 });
 
+test("ASCII read write consistency", () => {
+    const buffer = new BinaryBuffer();
+
+    const expected = "is this ascii?";
+    buffer.writeASCIIString(expected);
+
+    buffer.position = 0;
+
+    const actual = buffer.readASCIICharacters(expected.length);
+
+    expect(actual).toEqual(expected);
+});
+
+test('int8 read write consistency', () => {
+    const buffer = new BinaryBuffer();
+
+    buffer.writeInt8(0);
+    buffer.writeInt8(1);
+    buffer.writeInt8(-1);
+    buffer.writeInt8(-128);//max value
+    buffer.writeInt8(127);//max value
+
+    buffer.position = 0;
+
+    expect(buffer.readInt8()).toBe(0);
+    expect(buffer.readInt8()).toBe(1);
+    expect(buffer.readInt8()).toBe(-1);
+    expect(buffer.readInt8()).toBe(-128);
+    expect(buffer.readInt8()).toBe(127);
+});
+
+test('uint16 LE read write consistency', () => {
+    const buffer = new BinaryBuffer();
+
+    buffer.writeUint16LE(0);
+    buffer.writeUint16LE(1);
+    buffer.writeUint16LE(65535); //max value
+
+    buffer.position = 0;
+
+    expect(buffer.readUint16LE()).toBe(0);
+    expect(buffer.readUint16LE()).toBe(1);
+    expect(buffer.readUint16LE()).toBe(65535);
+});
+
+test('uint16 BE read write consistency', () => {
+    const buffer = new BinaryBuffer();
+
+    buffer.writeUint16BE(0);
+    buffer.writeUint16BE(1);
+    buffer.writeUint16BE(65535); //max value
+
+    buffer.position = 0;
+
+    expect(buffer.readUint16BE()).toBe(0);
+    expect(buffer.readUint16BE()).toBe(1);
+    expect(buffer.readUint16BE()).toBe(65535);
+});
 
 test('uint24 LE read write consistency', () => {
     const buffer = new BinaryBuffer();
@@ -194,3 +265,60 @@ test('uint24 BE read write consistency', () => {
     expect(buffer.readUint24BE()).toBe(1);
     expect(buffer.readUint24BE()).toBe(16777215);
 });
+
+
+test("setCapacity", () => {
+
+    const buffer = new BinaryBuffer();
+
+    buffer.setCapacity(1);
+
+    expect(buffer.capacity).toBe(1);
+
+    buffer.setCapacity(7);
+
+    expect(buffer.capacity).toBe(7);
+
+    // trying to reduce capacity below position should throw
+    buffer.position = 5;
+
+    expect(() => buffer.setCapacity(4)).toThrow();
+
+    // setting capacity to equal position should be fine
+    buffer.setCapacity(5);
+
+    expect(buffer.capacity).toBe(5);
+});
+
+test("trim sets capacity to current size", () => {
+    const buffer = new BinaryBuffer();
+
+    buffer.setCapacity(100);
+
+    buffer.writeUint24(123456);
+
+    buffer.trim();
+
+    expect(buffer.capacity).toBe(3);
+
+    // check that data was not destroyed
+    buffer.position = 0;
+
+    expect(buffer.readUint24()).toBe(123456);
+});
+
+test("ensureCapacity grows capacity as expected", () => {
+    const buffer = new BinaryBuffer();
+    buffer.setCapacity(1);
+
+    buffer.ensureCapacity(3);
+
+    expect(buffer.capacity).toBeGreaterThanOrEqual(3);
+
+    const capacity = buffer.capacity;
+
+    buffer.ensureCapacity(capacity);
+
+    // we're already at that capacity, we expect no change
+    expect(buffer.capacity).toEqual(capacity);
+});

package/src/core/binary/int32_to_binary_string.js

@@ -1,4 +1,4 @@
-
+import { assert } from "../assert.js";
 
 const RX = /\B(?=(.{8})+(?!.))/g;
 
@@ -15,6 +15,7 @@ const MAX_VALUE = 2 ** 31 - 1;
 const MIN_VALUE = -1 * (2 ** 31);
 
 /**
+ * Converts an integer to easily readable binary string representation
  * @see https://stackoverflow.com/questions/9939760/how-do-i-convert-an-integer-to-binary-in-javascript
  * @example 1024    -> "00000000 00000000 00000100 00000000"
  * @example -1      -> "11111111 11111111 11111111 11111111"
@@ -30,6 +31,8 @@ export function int32_to_binary_string(nMask) {
         throw "number too far negative, number shouldn't be < 2**31"//added
     }
 
+    assert.isInteger(nMask, 'nMask');
+
     let nFlag = 0, nShifted = nMask, sMask = '';
 
     for (; nFlag < 32;

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

@@ -0,0 +1,9 @@
+import { int32_to_binary_string } from "./int32_to_binary_string.js";
+
+test("sanity", () => {
+    expect(int32_to_binary_string(1024))
+        .toBe("00000000 00000000 00000100 00000000");
+
+    expect(int32_to_binary_string(-1))
+        .toBe("11111111 11111111 11111111 11111111");
+});

package/src/core/bvh2/BinaryNode.js

@@ -1149,36 +1149,6 @@ export class BinaryNode extends Node {
  */
 BinaryNode.prototype.isBinaryNode = true;
 
-/**
- * @see "Dynamic BVH" by Erin Catto / Blizzard
- * @param {AABB3} node
- * @param {AABB3} addition
- * @returns {number}
- */
-function inclusion_surface_area_heuristic(node, addition) {
-    return aabb3_combined_surface_area(node, addition) - aabb3_box_surface_area_2(node);
-}
-
-/**
- *
- * @param {BinaryNode|LeafNode} node
- * @param {AABB3} addition
- */
-function inclusion_cost_lower_bound(node, addition) {
-    let n = node;
-    let r = aabb3_box_surface_area_2(addition);
-
-    while (n !== null) {
-
-        r += n.costForInclusion(addition);
-
-        n = n.parentNode;
-    }
-
-    return r;
-}
-
-
 /**
  * @private
  * Used in intersection traversal methods. Should be invoked via Function.apply and Function.call only and not be called directly

package/src/core/bvh2/binary/2/BinaryUint32BVH.js

@@ -1,4 +1,4 @@
-import { array_copy } from "../../../collection/array/copyArray.js";
+import { array_copy } from "../../../collection/array/array_copy.js";
 import { min2 } from "../../../math/min2.js";
 import { max2 } from "../../../math/max2.js";
 import { ceilPowerOfTwo } from "../../../binary/operations/ceilPowerOfTwo.js";

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

@@ -6,7 +6,7 @@ import { min2 } from "../../math/min2.js";
 import { IndexedBinaryBVHVisitor } from "./IndexedBinaryBVHVisitor.js";
 import { NodeType } from "./NodeType.js";
 import { RayLeafIntersectionVisitor } from "./RayLeafIntersectionVisitor.js";
-import { array_copy } from "../../collection/array/copyArray.js";
+import { array_copy } from "../../collection/array/array_copy.js";
 
 
 /**

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

@@ -3,7 +3,7 @@ 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/copyArray.js";
+import { array_copy } from "../../collection/array/array_copy.js";
 
 export const COLUMN_PARENT = 6;
 export const COLUMN_CHILD_1 = 7;

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

@@ -1,7 +1,7 @@
 //
 
 
-import { array_copy } from "../../../collection/array/copyArray.js";
+import { array_copy } from "../../../collection/array/array_copy.js";
 import { NULL_NODE } from "../ExplicitBinaryBoundingVolumeHierarchy.js";
 import { aabb3_array_intersects_frustum_degree } from "../../../geom/3d/aabb/aabb3_array_intersects_frustum_degree.js";
 import { bvh_collect_user_data } from "./bvh_collect_user_data.js";

package/src/core/cache/Cache.js

@@ -301,6 +301,15 @@ export class Cache {
         this.onSet.send2(key, value);
     }
 
+    /**
+     *
+     * @param {Key} key
+     * @returns {boolean}
+     */
+    contains(key) {
+        return this.data.has(key);
+    }
+
     /**
      *
      * @param {Key} key
@@ -318,31 +327,26 @@ export class Cache {
         }
     }
 
-    /**
-     *
-     * @param {Key} key
-     * @returns {boolean}
-     */
-    contains(key) {
-        return this.data.has(key);
-    }
 
     /**
-     * Remove without triggering {@link #removeListener}
+     * Please note that the key will be stored inside the cache, so it must be treated as immutable
      * @param {Key} key
-     * @returns {boolean} true if element was removed, false otherwise
+     * @param {function(Key):Value} compute
+     * @param {*} [compute_context]
+     * @return {Value}
      */
-    silentRemove(key) {
-        const element = this.data.get(key);
+    getOrCompute(key, compute, compute_context) {
+        const existing = this.get(key);
 
-        if (element === undefined) {
-            //nothing to do
-            return false;
+        if (existing !== null) {
+            return existing;
         }
 
-        this.__removeElement(element);
+        const value = compute.call(compute_context, key);
 
-        return true;
+        this.set(key, value);
+
+        return value;
     }
 
     /**
@@ -398,24 +402,22 @@ export class Cache {
     }
 
     /**
-     * Please note that the key will be stored inside the cache, so it must be treated as immutable
+     * Remove without triggering {@link #removeListener}
+     * NOTE: please be sure you understand what you're doing when you use this method
      * @param {Key} key
-     * @param {function(Key):Value} compute
-     * @param {*} [compute_context]
-     * @return {Value}
+     * @returns {boolean} true if element was removed, false otherwise
      */
-    getOrCompute(key, compute, compute_context) {
-        const existing = this.get(key);
+    silentRemove(key) {
+        const element = this.data.get(key);
 
-        if (existing !== null) {
-            return existing;
+        if (element === undefined) {
+            //nothing to do
+            return false;
         }
 
-        const value = compute.call(compute_context, key);
-
-        this.set(key, value);
+        this.__removeElement(element);
 
-        return value;
+        return true;
     }
 
     /**

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

@@ -93,12 +93,15 @@ test("store and retrieve the same item", () => {
 test("remove method", () => {
     const cache = new Cache();
 
+    expect(cache.remove("a")).toBe(false);
+
     cache.put("a", "b");
 
-    cache.remove("a");
+    expect(cache.remove("a")).toBe(true);
 
     expect(cache.size()).toBe(0);
     expect(cache.get("a")).toBe(null);
+
 });
 
 test("replacing element with the same key", () => {

package/src/core/collection/HashMap.js

@@ -5,7 +5,7 @@ import { isPowerOfTwo } from "../math/isPowerOrTwo.js";
 import { ctz32 } from "../binary/ctz32.js";
 import { ceilPowerOfTwo } from "../binary/operations/ceilPowerOfTwo.js";
 import { UintArrayForCount } from "./array/typed/uint_array_for_count.js";
-import { array_copy } from "./array/copyArray.js";
+import { array_copy } from "./array/array_copy.js";
 import { min2 } from "../math/min2.js";
 import { arraySwapElements } from "./array/arraySwapElements.js";
 

package/src/core/collection/array/{copyArray.js → array_copy.js}

@@ -1,29 +1,6 @@
 /**
- * @template T
- * @param {T[]} source
- * @param {T[]} target
- */
-export function copyArray(source, target) {
-
-    const n = source.length;
-    for (let i = 0; i < n; i++) {
-        const v = source[i];
-
-        target[i] = v;
-    }
-
-
-    const tL = target.length;
-
-    if (n > tL) {
-        target.splice(n, tL - n);
-    }
-}
-
-
-/**
- * Follows Java System.arraycopy interface
  * Copy data from one array to another
+ * Follows Java System.arraycopy interface
  * @template T
  * @param {T[]|ArrayLike<T>|TypedArray|Uint8ClampedArray|Uint8Array|Uint32Array|Int32Array|Float32Array|Float64Array} source The source array
  * @param {number} source_position Starting position where to copy from inside the source array

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

@@ -0,0 +1,21 @@
+/**
+ * @template T
+ * @param {T[]} source
+ * @param {T[]} target
+ */
+export function array_copy_entire(source, target) {
+
+    const n = source.length;
+    for (let i = 0; i < n; i++) {
+        const v = source[i];
+
+        target[i] = v;
+    }
+
+
+    const tL = target.length;
+
+    if (n > tL) {
+        target.splice(n, tL - n);
+    }
+}

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

@@ -1,4 +1,4 @@
-import { array_copy } from "../copyArray.js";
+import { array_copy } from "../array_copy.js";
 
 
 /**

package/src/core/collection/queue/Deque.d.ts

@@ -15,6 +15,10 @@ export class Deque<T> {
 
     peek(): T | undefined
 
+    getFirst(): T | undefined
+
+    getLast(): T | undefined
+
     pop(): T
 
     add(e: T): void

package/src/core/collection/queue/Deque.js

@@ -1,6 +1,6 @@
 import { ceilPowerOfTwo } from "../../binary/operations/ceilPowerOfTwo.js";
 import { max2 } from "../../math/max2.js";
-import { array_copy } from "../array/copyArray.js";
+import { array_copy } from "../array/array_copy.js";
 import { assert } from "../../assert.js";
 
 const DEFAULT_SIZE = 16;
@@ -21,7 +21,7 @@ export class Deque {
 
         assert.isNonNegativeInteger(minSize, 'minSize');
 
-        const size = ceilPowerOfTwo(max2(DEFAULT_SIZE, minSize));
+        const size = ceilPowerOfTwo(max2(1, minSize));
 
         /**
          * Using static array allocator to preserve data locality.
@@ -254,11 +254,10 @@ export class Deque {
 
     /**
      * Peek element from the front of the queue without removing it
-     * @returns {T}
+     * @returns {T|undefined}
      */
     getFirst() {
-        const element = this.__data[this.__head];
-        return element;
+        return this.__data[this.__head];
     }
 
     /**
@@ -292,8 +291,7 @@ export class Deque {
      */
     getLast() {
         const last = this.__circularSmallerPos(this.__tail);
-        const element = this.__data[last];
-        return element;
+        return this.__data[last];
     }
 }
 

package/src/core/collection/queue/Deque.spec.js

@@ -1,7 +1,15 @@
 import { Deque } from "./Deque.js";
 
 test("constructor doesn't throw ", () => {
+    expect(() => new Deque()).not.toThrow();
+});
+
+test("add one element", () => {
     const deque = new Deque();
+
+    deque.add(1);
+
+    expect(deque.size()).toBe(1);
 });
 
 test('first in last out, forward', () => {
@@ -138,3 +146,102 @@ test("remove middle item", () => {
     expect(deque.pop()).toBe(7);
     expect(deque.pop()).toBe(17);
 });
+
+test("remove non-existent element", () => {
+
+    const deque = new Deque();
+
+    expect(deque.remove(1)).toBe(false);
+
+    deque.add(3);
+
+    expect(deque.remove(1)).toBe(false);
+
+    expect(deque.size()).toBe(1);
+});
+
+
+test("clear", () => {
+
+    const deque = new Deque();
+
+    expect(() => deque.clear()).not.toThrow();
+
+    expect(deque.size()).toBe(0);
+
+    deque.add('x');
+
+    deque.clear();
+
+    expect(deque.size()).toBe(0);
+
+});
+
+test("has", () => {
+
+    const deque = new Deque();
+
+    expect(deque.has(1)).toBe(false);
+
+    deque.add(1);
+
+    expect(deque.has(1)).toBe(true);
+});
+
+test("getFirst", () => {
+
+    const deque = new Deque();
+
+    expect(deque.getFirst()).toBeUndefined();
+
+    deque.addFirst(1);
+
+    expect(deque.getFirst()).toBe(1);
+
+    deque.addFirst(3);
+
+    expect(deque.getFirst()).toBe(3);
+});
+
+test("getLast", () => {
+
+    const deque = new Deque();
+
+    expect(deque.getFirst()).toBeUndefined();
+
+    deque.addFirst(1);
+
+    expect(deque.getLast()).toBe(1);
+
+    deque.addFirst(3);
+
+    expect(deque.getLast()).toBe(1);
+
+    deque.removeLast();
+
+    expect(deque.getLast()).toBe(3);
+});
+
+test("fill queue beyond default size and then drain it", () => {
+    const queue = new Deque(1);
+
+    queue.add(1);
+    expect(queue.size()).toBe(1);
+
+    queue.add(2);
+    expect(queue.size()).toBe(2);
+
+    queue.add(3);
+    expect(queue.size()).toBe(3);
+
+    // Drain
+
+    expect(queue.pop()).toBe(1);
+    expect(queue.size()).toBe(2);
+
+    expect(queue.pop()).toBe(2);
+    expect(queue.size()).toBe(1);
+
+    expect(queue.pop()).toBe(3);
+    expect(queue.size()).toBe(0);
+});

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

@@ -6,7 +6,7 @@
 import { assert } from "../../assert.js";
 import Signal from "../../events/signal/Signal.js";
 import { max2 } from "../../math/max2.js";
-import { array_copy } from "../array/copyArray.js";
+import { array_copy } from "../array/array_copy.js";
 
 /**
  *

package/src/core/geom/2d/aabb/AABB2.d.ts

@@ -1,3 +1,5 @@
+import Vector2 from "../../Vector2";
+
 export default class AABB2 {
     x0: number
     y0: number
@@ -12,6 +14,10 @@ export default class AABB2 {
 
     copy(other: AABB2): void
 
+    clone(): AABB2
+
+    equals(other: AABB2): boolean
+
     setBoundsUnordered(x0: number, y0: number, x1: number, y1: number): void
 
     getHeight(): number
@@ -24,5 +30,13 @@ export default class AABB2 {
 
     shrink(size: number): void
 
+    _expandToFitPoint(x: number, y: number): void
+
     setNegativelyInfiniteBounds(): void
+
+    lineIntersectionPoint(v0: Vector2, v1: Vector2, result: Vector2): boolean
+
+    toJSON(): any
+
+    fromJSON(json: any): void
 }