@woosh/meep-engine 2.50.3 → 2.52.0

package/src/engine/graphics/three/expand_aabb_by_transformed_three_object.spec.js

@@ -0,0 +1,108 @@
+import { expand_aabb_by_transformed_three_object } from "./expand_aabb_by_transformed_three_object.js";
+import { MATRIX_4_IDENTITY } from "../../../core/geom/3d/matrix/MATRIX_4_IDENTITY.js";
+import { BufferAttribute, BufferGeometry, Group, Mesh } from "three";
+
+/**
+ *
+ * @param {Object3D} object
+ * @return {number[]}
+ */
+function compute(object) {
+    object.updateMatrixWorld();
+
+    const result = [
+        Infinity, Infinity, Infinity,
+        -Infinity, -Infinity, -Infinity
+    ];
+
+    expand_aabb_by_transformed_three_object(result, object, MATRIX_4_IDENTITY);
+
+    return result;
+}
+
+/**
+ *
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @return {BufferGeometry}
+ */
+function makePointGeometry(x, y, z) {
+    const geo = new BufferGeometry();
+    geo.setIndex([0, 0, 0]);
+    geo.setAttribute(
+        "position",
+        new BufferAttribute(new Float32Array([x, y, z]), 3, false)
+    );
+    return geo;
+}
+
+test("single point at depth 0", () => {
+
+    const geo = makePointGeometry(1, 3, 5);
+
+    const aabb = compute(new Mesh(geo));
+
+    expect(aabb[0]).toBeCloseTo(1);
+    expect(aabb[3]).toBeCloseTo(1);
+
+    expect(aabb[1]).toBeCloseTo(3);
+    expect(aabb[4]).toBeCloseTo(3);
+
+    expect(aabb[2]).toBeCloseTo(5);
+    expect(aabb[5]).toBeCloseTo(5);
+});
+
+test("single point at depth 1", () => {
+
+    const geo = makePointGeometry(1, 3, 5);
+
+    const object_1 = new Group();
+    const object_2 = new Mesh(geo);
+
+    object_1.add(object_2);
+    object_2.position.set(7, -11, 13);
+
+    const aabb = compute(object_1);
+
+    expect(aabb[0]).toBeCloseTo(8);
+    expect(aabb[3]).toBeCloseTo(8);
+
+    expect(aabb[1]).toBeCloseTo(-8);
+    expect(aabb[4]).toBeCloseTo(-8);
+
+    expect(aabb[2]).toBeCloseTo(18);
+    expect(aabb[5]).toBeCloseTo(18);
+});
+
+test("single point at depth 2", () => {
+
+    const geo = makePointGeometry(1, 3, 5);
+
+    const object_0 = new Group();
+    const object_1 = new Group();
+    const object_2 = new Mesh(geo);
+
+    object_0.add(object_1);
+    object_1.add(object_2);
+
+    object_1.position.set(10, 20, 30);
+    object_1.scale.set(0.1, 0.2, 0.5);
+
+    object_2.position.set(7, -17, 13);
+
+    const aabb = compute(object_0);
+
+    const x = 10 + 8 * 0.1;
+
+    expect(aabb[0]).toBeCloseTo(x);
+    expect(aabb[3]).toBeCloseTo(x);
+
+    const y = 20 - 14 * 0.2;
+    expect(aabb[1]).toBeCloseTo(y);
+    expect(aabb[4]).toBeCloseTo(y);
+
+    const z = 30 + 18 * 0.5;
+    expect(aabb[2]).toBeCloseTo(z);
+    expect(aabb[5]).toBeCloseTo(z);
+});

package/src/engine/graphics/trail/TemporalPath.js

@@ -1,124 +1,129 @@
 import { RowFirstTable } from "../../../core/collection/table/RowFirstTable.js";
 import { BinaryDataType } from "../../../core/binary/type/BinaryDataType.js";
+import { RowFirstTableSpec } from "../../../core/collection/table/RowFirstTableSpec.js";
 
+const TABLE_SPEC = RowFirstTableSpec.get([
+    // time
+    BinaryDataType.Float32,
+    // position XYZ
+    BinaryDataType.Float32, BinaryDataType.Float32, BinaryDataType.Float32
+]);
 
-function TemporalPath() {
+/**
+ * Keeps tracks of a moving point for a given time window
+ */
+export class TemporalPath {
     /**
      * How long to track the points for
      * @type {number}
      */
-    this.memory = 0;
+    memory = 0;
 
     /**
      *
      * @type {number}
      */
-    this.time = 0;
+    time = 0;
 
     /**
      *
      * @type {RowFirstTable}
      */
-    this.data = new RowFirstTable([
-        BinaryDataType.Float32,
-        BinaryDataType.Float32, BinaryDataType.Float32, BinaryDataType.Float32
-    ]);
-}
+    data = new RowFirstTable(TABLE_SPEC);
 
-const tempSequenceRecord = [];
+    updateSequence() {
+        const sequence = this.data;
+        //determine if position sequence can be cropped
+        const numRecords = sequence.length;
 
-TemporalPath.prototype.updateSequence = function () {
-    const sequence = this.data;
-    //determine if position sequence can be cropped
-    const numRecords = sequence.length;
+        if (numRecords === 0) {
+            return;
+        }
 
-    if (numRecords === 0) {
-        return;
-    }
+        const lastUsefulMemory = this.time - this.memory;
 
-    const lastUsefulMemory = this.time - this.memory;
+        let i = 0;
 
-    let i = 0;
+        while (i < numRecords && sequence.readCellValue(i, 0) < lastUsefulMemory) {
+            i++;
+        }
 
-    while (i < numRecords && sequence.readCellValue(i, 0) < lastUsefulMemory) {
-        i++;
+        if (i > 0) {
+            sequence.removeRows(0, i);
+        }
     }
 
-    if (i > 0) {
-        sequence.removeRows(0,i);
-    }
-};
+    /**
+     *
+     * @param {number} timeDelta
+     */
+    update(timeDelta) {
+        this.time += timeDelta;
 
-/**
- *
- * @param {number} timeDelta
- */
-TemporalPath.prototype.update = function (timeDelta) {
-    this.time += timeDelta;
+        this.updateSequence();
+    }
 
-    this.updateSequence();
-};
+    /**
+     * @returns {number}
+     */
+    computeLength() {
 
-/**
- * @returns {number}
- */
-TemporalPath.prototype.computeLength = function () {
+        let i;
+        const numRecords = this.data.length;
 
-    let i;
-    const numRecords = this.data.length;
+        if (numRecords === 0) {
+            return 0;
+        }
 
-    if (numRecords === 0) {
-        return 0;
-    }
+        let _x, _y, _z;
 
-    let _x, _y, _z;
+        this.data.getRow(0, tempSequenceRecord);
 
-    this.data.getRow(0, tempSequenceRecord);
+        _x = tempSequenceRecord[1];
+        _y = tempSequenceRecord[2];
+        _z = tempSequenceRecord[3];
 
-    _x = tempSequenceRecord[1];
-    _y = tempSequenceRecord[2];
-    _z = tempSequenceRecord[3];
 
+        let result = 0;
 
-    let result = 0;
+        for (i = 1; i < numRecords; i++) {
+            this.data.getRow(i, tempSequenceRecord);
 
-    for (i = 1; i < numRecords; i++) {
-        this.data.getRow(i, tempSequenceRecord);
+            const x = tempSequenceRecord[1];
+            const y = tempSequenceRecord[2];
+            const z = tempSequenceRecord[3];
 
-        const x = tempSequenceRecord[1];
-        const y = tempSequenceRecord[2];
-        const z = tempSequenceRecord[3];
+            const dX = x - _x;
+            const dY = y - _y;
+            const dZ = z - _z;
 
-        const dX = x - _x;
-        const dY = y - _y;
-        const dZ = z - _z;
+            const d = Math.sqrt(dX * dX + dY * dY + dZ * dZ);
 
-        const d = Math.sqrt(dX * dX + dY * dY + dZ * dZ);
+            result += d;
 
-        result += d;
+            //remember current coordinates
+            _x = x;
+            _y = y;
+            _z = z;
+        }
 
-        //remember current coordinates
-        _x = x;
-        _y = y;
-        _z = z;
+        return result;
     }
 
-    return result;
-};
-
-/**
- *
- * @param {number} x
- * @param {number} y
- * @param {number} z
- */
-TemporalPath.prototype.append = function (x, y, z) {
-    tempSequenceRecord[0] = this.time;
-    tempSequenceRecord[1] = x;
-    tempSequenceRecord[2] = y;
-    tempSequenceRecord[3] = z;
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     */
+    append(x, y, z) {
+        tempSequenceRecord[0] = this.time;
+        tempSequenceRecord[1] = x;
+        tempSequenceRecord[2] = y;
+        tempSequenceRecord[3] = z;
 
-    this.data.addRow(tempSequenceRecord);
-};
+        this.data.addRow(tempSequenceRecord);
+    }
+}
 
-export { TemporalPath };
+const tempSequenceRecord = [];

package/src/engine/graphics/trail/TemporalPath.spec.js

@@ -0,0 +1,5 @@
+import { TemporalPath } from "./TemporalPath.js";
+
+test("constructor does not throw", () => {
+    expect(() => new TemporalPath()).not.toThrow();
+});

package/src/engine/graphics/trail/x/RibbonX.spec.js

@@ -0,0 +1,5 @@
+import { RibbonX } from "./RibbonX.js";
+
+test("constructor does not throw", () => {
+    expect(() => new RibbonX()).not.toThrow();
+});

package/src/engine/grid/components/GridObstacle.js

@@ -10,10 +10,13 @@ import { isArrayEqualStrict } from "../../../core/collection/array/isArrayEqualS
 import { computeHashIntegerArray } from "../../../core/collection/array/computeHashIntegerArray.js";
 
 class GridObstacle {
-    constructor() {
-        this.data = [1];
-        this.size = new Vector2(1, 1);
-    }
+    data = [1];
+
+    /**
+     * @readonly
+     * @type {Vector2}
+     */
+    size = new Vector2(1, 1);
 
     /**
      *
@@ -21,8 +24,8 @@ class GridObstacle {
      * @param {number} h
      */
     resize(w, h) {
-        assert.ok(Number.isInteger(w) && w >= 0, `expected non-negative integer, got ${w}`);
-        assert.ok(Number.isInteger(h) && h >= 0, `expected non-negative integer, got ${h}`);
+        assert.isNonNegativeInteger(w, 'w');
+        assert.isNonNegativeInteger(h, 'h');
 
         const x1 = this.size.x;
         const y1 = this.size.y;
@@ -61,9 +64,9 @@ class GridObstacle {
      * @param {*} [thisArg]
      */
     traverseMask(offsetX, offsetY, visitor, thisArg) {
-        assert.typeOf(offsetX, 'number', 'offsetX');
-        assert.typeOf(offsetY, 'number', 'offsetY');
-        assert.typeOf(visitor, 'function', 'visitor');
+        assert.isNumber(offsetX, 'offsetX');
+        assert.isNumber(offsetY, 'offsetY');
+        assert.isFunction(visitor, 'visitor');
 
         const size = this.size;
         const sX = size.x;
@@ -100,11 +103,11 @@ class GridObstacle {
      * @returns {number}
      */
     readPoint(x, y) {
-        assert.typeOf(x, 'number', 'x');
-        assert.typeOf(y, 'number', 'y');
+        assert.isNumber(x, 'x');
+        assert.isNumber(y, 'y');
 
-        assert.ok(Number.isInteger(x), `expected x to be an integer, got ${x} instead`);
-        assert.ok(Number.isInteger(y), `expected y to be an integer, got ${y} instead`);
+        assert.isInteger(x, 'x');
+        assert.isInteger(y, 'y');
 
         const index = y * this.size.x + x;
         return this.data[index];
@@ -117,6 +120,9 @@ class GridObstacle {
      * @param {number} value
      */
     writePoint(x, y, value) {
+        assert.isNonNegativeInteger(value, 'value');
+        assert.lessThanOrEqual(value, 255);
+
         const index = y * this.size.x + x;
 
         this.data[index] = value;
@@ -129,8 +135,8 @@ class GridObstacle {
      * @returns {boolean}
      */
     isPointWithin(x, y) {
-        assert.typeOf(x, 'number', 'x');
-        assert.typeOf(y, 'number', 'y');
+        assert.isNumber(x, 'x');
+        assert.isNumber(y, 'y');
 
         const size = this.size;
 
@@ -141,18 +147,20 @@ class GridObstacle {
     }
 
     /**
-     *
+     * Is a given point adjacent to a blocking cell?
      * @param {number} x Obstacle-Local X position
      * @param {number} y Obstacle-Local Y position
      * @param {number[]} adjacencyMask Mask that defines adjacency, contains pairs of number for each X,Y coordinate offset from obstacle point
      * @returns {boolean}
      */
     isPointAdjacent(x, y, adjacencyMask) {
-        assert.typeOf(x, 'number', 'x');
-        assert.typeOf(y, 'number', 'y');
+        assert.isNumber(x, 'x');
+        assert.isNumber(y, 'y');
+
+        assert.defined(adjacencyMask, 'mask');
+        assert.notNull(adjacencyMask, 'mask');
 
-        assert.notEqual(adjacencyMask, undefined, 'mask is undefined');
-        assert.notEqual(adjacencyMask, null, 'mask is null');
+        assert.isArrayLike(adjacencyMask, 'mask');
 
         const size = this.size;
 
@@ -163,7 +171,8 @@ class GridObstacle {
 
         const maskLength = adjacencyMask.length;
 
-        assert.typeOf(maskLength, 'number', 'maskLength');
+        assert.isNonNegativeInteger(maskLength, 'maskLength');
+        assert.equal(maskLength % 2, 0, `maskLength must be a multiple of 2`);
 
 
         for (let k = 0; k < maskLength; k += 2) {
@@ -203,16 +212,27 @@ class GridObstacle {
         };
     }
 
-    fromJSON(v) {
-        const size = v.size;
+    fromJSON({ size, data }) {
+        assert.isArrayLike(data, 'data');
+
         this.size.fromJSON(size);
 
         const sX = this.size.x;
         const sY = this.size.y;
 
+        assert.equal(data.length, sX * sY, 'invalid array length');
+
         this.data = new Uint8Array(sX * sY);
 
-        this.data.set(v.data, 0);
+        this.data.set(data, 0);
+    }
+
+    static fromJSON(j) {
+        const r = new GridObstacle();
+
+        r.fromJSON(j);
+
+        return r;
     }
 
     /**
@@ -221,7 +241,7 @@ class GridObstacle {
      */
     hash() {
         return computeHashIntegerArray(
-            this.size.hashCode(),
+            this.size.hash(),
             computeIntegerArrayHash(this.data, 0, this.data.length)
         );
     }

package/src/engine/grid/components/GridObstacle.spec.js

@@ -43,4 +43,133 @@ test('resize 1x2 to 1x1', () => {
     g.resize(1, 1);
 
     expect(g.data[0]).toBe(3);
-});
+});
+
+test("readPoint", () => {
+    const g = new GridObstacle();
+
+    g.resize(2, 2);
+
+    g.data[0] = 1;
+    g.data[1] = 3;
+    g.data[2] = 5;
+    g.data[3] = 7;
+
+    expect(g.readPoint(0, 0)).toBe(1);
+    expect(g.readPoint(1, 0)).toBe(3);
+    expect(g.readPoint(0, 1)).toBe(5);
+    expect(g.readPoint(1, 1)).toBe(7);
+});
+
+test("writePoint", () => {
+
+    const g = new GridObstacle();
+
+    g.resize(2, 2);
+
+    g.writePoint(0, 0, 1);
+    g.writePoint(1, 0, 3);
+    g.writePoint(0, 1, 5);
+    g.writePoint(1, 1, 7);
+
+    expect(Array.from(g.data)).toEqual([1, 3, 5, 7]);
+});
+
+
+test("hash", () => {
+    const g = new GridObstacle();
+
+    const hash = g.hash();
+
+    expect(typeof hash).toEqual("number");
+    expect(Number.isInteger(hash)).toBe(true);
+    expect(g.hash()).toEqual(hash); // stability
+});
+
+test("to/from JSON consistency", () => {
+
+    const a = new GridObstacle();
+    a.resize(1, 3);
+
+    a.writePoint(0, 0, 1);
+    a.writePoint(0, 1, 3);
+    a.writePoint(0, 2, 7);
+
+    const b = new GridObstacle();
+
+    b.fromJSON(a.toJSON());
+
+    expect(b.size.x).toEqual(1);
+    expect(b.size.y).toEqual(3);
+
+    expect(b.readPoint(0, 0)).toEqual(1);
+    expect(b.readPoint(0, 1)).toEqual(3);
+    expect(b.readPoint(0, 2)).toEqual(7);
+});
+
+test("equals", () => {
+    const a = new GridObstacle();
+    const b = new GridObstacle();
+
+    const c = GridObstacle.fromJSON({
+        size: { x: 1, y: 1 },
+        data: [
+            7
+        ]
+    });
+
+    const d = GridObstacle.fromJSON({
+        size: { x: 2, y: 3 },
+        data: [
+            1, 3,
+            5, 7,
+            11, 13
+        ]
+    });
+
+    const f = GridObstacle.fromJSON({
+        size: { x: 2, y: 3 },
+        data: [
+            1, 3,
+            5, 7,
+            11, 13
+        ]
+    });
+
+    const g = GridObstacle.fromJSON({
+        size: { x: 3, y: 2 },
+        data: [
+            1, 3,
+            5, 7,
+            11, 13
+        ]
+    });
+
+    const h = GridObstacle.fromJSON({
+        size: { x: 3, y: 2 },
+        data: [
+            1, 3,
+            5, 7,
+            17, 13
+        ]
+    });
+
+    expect(a.equals(b)).toBe(true);
+    expect(a.equals(c)).toBe(false);
+    expect(a.equals(d)).toBe(false);
+
+    expect(f.equals(g)).toBe(false);
+    expect(g.equals(h)).toBe(false);
+});
+
+test("isPointAdjacent", () => {
+    const grid = new GridObstacle();
+
+    grid.writePoint(0, 0, 7);
+
+    expect(grid.isPointAdjacent(0, 0, [0, 0])).toBe(true);
+
+    grid.writePoint(0, 0, 0);
+
+    expect(grid.isPointAdjacent(0, 0, [0, 0])).toBe(false);
+});

package/src/engine/grid/components/GridPosition.js

@@ -4,23 +4,11 @@
 
 import Vector2 from '../../../core/geom/Vector2.js';
 
-class GridPosition extends Vector2{
-    /**
-     * @extends {Vector2}
-     * @constructor
-     */
-    constructor() {
-        super();
-    }
-
-    /**
-     *
-     * @param {GridPosition|Vector2} other
-     */
-    copy(other) {
-        Vector2.prototype.copy.call(this, other);
-        return this;
-    }
+/**
+ * @extends {Vector2}
+ * @class
+ */
+class GridPosition extends Vector2 {
 
     clone() {
         const clone = new GridPosition();