@woosh/meep-engine 2.51.0 → 2.52.0

package/src/engine/graphics/texture/sampler/Sampler2D.js

@@ -15,7 +15,7 @@ import {
     compute_typed_array_constructor_from_data_type
 } from "../../../../core/binary/type/DataType2TypedArrayConstructorMapping.js";
 import { Base64 } from "../../../../core/binary/Base64.js";
-import { computeStridedIntegerArrayHash } from "../../../computeStridedIntegerArrayHash.js";
+import { computeStridedIntegerArrayHash } from "../../../../core/primitives/array/computeStridedIntegerArrayHash.js";
 import { is_typed_array_equals } from "../../../../core/collection/array/typed/is_typed_array_equals.js";
 
 /**

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

@@ -2,6 +2,7 @@ import { ensureGeometryBoundingBox } from "../util/ensureGeometryBoundingBox.js"
 import { aabb3_matrix4_project } from "../../../core/geom/3d/aabb/aabb3_matrix4_project.js";
 import { aabb3_array_combine } from "../../../core/geom/3d/aabb/aabb3_array_combine.js";
 import { m4_multiply } from "../../../core/geom/3d/matrix/m4_multiply.js";
+import { aabb3_from_threejs_geometry } from "../../../core/geom/3d/aabb/aabb3_from_threejs_geometry.js";
 
 const scratch_aabb3_array_0 = new Float32Array(6);
 const scratch_aabb3_array_1 = new Float32Array(6);
@@ -10,7 +11,7 @@ const scratch_aabb3_array_1 = new Float32Array(6);
  *
  * @param {number[]|Float32Array} result
  * @param {Object3D} object
- * @param {number[]|Float32Array} transform
+ * @param {number[]|Float32Array} transform 4x4 transform matrix to be used as a root transform instead of whatever is set on the object, this lets us compute local-space bounds without having to modify the source object
  */
 export function expand_aabb_by_transformed_three_object(result, object, transform) {
 
@@ -22,28 +23,7 @@ export function expand_aabb_by_transformed_three_object(result, object, transfor
     if (geometry !== undefined) {
 
         ensureGeometryBoundingBox(geometry);
-
-        const gbb = geometry.boundingBox;
-
-        const min = gbb.min;
-
-        const x0 = min.x;
-        const y0 = min.y;
-        const z0 = min.z;
-
-        const max = gbb.max;
-
-        const x1 = max.x;
-        const y1 = max.y;
-        const z1 = max.z;
-
-        scratch_aabb3_array_0[0] = x0;
-        scratch_aabb3_array_0[1] = y0;
-        scratch_aabb3_array_0[2] = z0;
-
-        scratch_aabb3_array_0[3] = x1;
-        scratch_aabb3_array_0[4] = y1;
-        scratch_aabb3_array_0[5] = z1;
+        aabb3_from_threejs_geometry(scratch_aabb3_array_0,geometry);
 
         aabb3_matrix4_project(scratch_aabb3_array_1, scratch_aabb3_array_0, transform);
 

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();

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

@@ -1,5 +1,4 @@
 import Vector2 from "../../../core/geom/Vector2.js";
-import { BinaryClassSerializationAdapter } from "../../ecs/storage/binary/BinaryClassSerializationAdapter.js";
 import { BinaryClassUpgrader } from "../../ecs/storage/binary/BinaryClassUpgrader.js";
 import { GridPosition2TransformFlags } from "./GridPosition2TransformFlags.js";
 
@@ -116,7 +115,7 @@ export class GridPosition2Transform {
      * @returns {number}
      */
     hash() {
-        return this.offset.hashCode();
+        return this.offset.hash();
     }
 
 }
@@ -124,74 +123,6 @@ export class GridPosition2Transform {
 GridPosition2Transform.typeName = "GridPosition2Transform";
 
 
-export class GridPosition2TransformSerializationAdapter extends BinaryClassSerializationAdapter {
-    constructor() {
-        super();
-
-        this.klass = GridPosition2Transform;
-        this.version = 1;
-    }
-
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     * @param {GridPosition2Transform} value
-     */
-    serialize(buffer, value) {
-        const offsetX = value.offset.x;
-        const offsetY = value.offset.y;
-
-        let header = 3;
-        if (offsetX === 0 && offsetY === 0) {
-            header = 0;
-        } else if (offsetX === 0) {
-            header = 2;
-        } else if (offsetY === 0) {
-            header = 1;
-        } else {
-            //both coordinates are present
-            header = 3;
-        }
-
-        buffer.writeUint8(header);
-
-        if ((header & 1) !== 0) {
-            //write X
-            buffer.writeFloat32(offsetX);
-        }
-
-        if ((header & 2) !== 0) {
-            //write Y
-            buffer.writeFloat32(offsetY);
-        }
-    }
-
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     * @param {GridPosition2Transform} value
-     */
-    deserialize(buffer, value) {
-        //read header
-        const header = buffer.readUint8();
-
-
-        let offsetX = 0, offsetY = 0;
-
-        if ((header & 1) !== 0) {
-            //write X
-            offsetX = buffer.readFloat32();
-        }
-
-        if ((header & 2) !== 0) {
-            //write Y
-            offsetY = buffer.readFloat32();
-        }
-
-        value.offset.set(offsetX, offsetY);
-    }
-}
-
 export class GridPosition2TransformSerializationUpgrader_0_1 extends BinaryClassUpgrader {
     constructor() {
         super();

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

@@ -0,0 +1,70 @@
+import { BinaryClassSerializationAdapter } from "../../ecs/storage/binary/BinaryClassSerializationAdapter.js";
+import { GridPosition2Transform } from "./GridPosition2Transform.js";
+
+export class GridPosition2TransformSerializationAdapter extends BinaryClassSerializationAdapter {
+    constructor() {
+        super();
+
+        this.klass = GridPosition2Transform;
+        this.version = 1;
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {GridPosition2Transform} value
+     */
+    serialize(buffer, value) {
+        const offsetX = value.offset.x;
+        const offsetY = value.offset.y;
+
+        let header = 3;
+        if (offsetX === 0 && offsetY === 0) {
+            header = 0;
+        } else if (offsetX === 0) {
+            header = 2;
+        } else if (offsetY === 0) {
+            header = 1;
+        } else {
+            //both coordinates are present
+            header = 3;
+        }
+
+        buffer.writeUint8(header);
+
+        if ((header & 1) !== 0) {
+            //write X
+            buffer.writeFloat32(offsetX);
+        }
+
+        if ((header & 2) !== 0) {
+            //write Y
+            buffer.writeFloat32(offsetY);
+        }
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {GridPosition2Transform} value
+     */
+    deserialize(buffer, value) {
+        //read header
+        const header = buffer.readUint8();
+
+
+        let offsetX = 0, offsetY = 0;
+
+        if ((header & 1) !== 0) {
+            //write X
+            offsetX = buffer.readFloat32();
+        }
+
+        if ((header & 2) !== 0) {
+            //write Y
+            offsetY = buffer.readFloat32();
+        }
+
+        value.offset.set(offsetX, offsetY);
+    }
+}

package/src/engine/plugin/EnginePlugin.js

@@ -2,22 +2,20 @@ import { BaseProcess } from "../../core/process/BaseProcess.js";
 import { assert } from "../../core/assert.js";
 
 export class EnginePlugin extends BaseProcess {
-    constructor() {
-        super();
 
-        /**
-         *
-         * @type {Class<EnginePlugin>[]}
-         * @private
-         */
-        this.__dependencies = [];
+    /**
+     *
+     * @type {Class<EnginePlugin>[]}
+     * @private
+     */
+    __dependencies = [];
+
+    /**
+     *
+     * @type {Engine|null}
+     */
+    engine = null;
 
-        /**
-         *
-         * @type {Engine|null}
-         */
-        this.engine = null;
-    }
 
     attach() {
         /**

package/src/engine/plugin/EnginePlugin.spec.js

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

package/src/engine/plugin/EnginePluginManager.js

@@ -6,29 +6,25 @@ import { isSubclassOf } from "./isSubclassOf.js";
 import { assert } from "../../core/assert.js";
 
 export class EnginePluginManager extends BaseProcess {
-    constructor() {
-        super();
-
-        /**
-         * @private
-         * @type {Map<Class, PluginReferenceContext>}
-         */
-        this.__plugins = new Map();
-
-        /**
-         *
-         * @type {Engine}
-         */
-        this.engine = null;
-
-        /**
-         *
-         * @type {number}
-         * @private
-         */
-        this.__version = 0;
-    }
 
+    /**
+     * @private
+     * @type {Map<Class, PluginReferenceContext>}
+     */
+    __plugins = new Map();
+
+    /**
+     *
+     * @type {Engine}
+     */
+    engine = null;
+
+    /**
+     *
+     * @type {number}
+     * @private
+     */
+    __version = 0;
 
     /**
      *

package/src/engine/scene/transitionToScene.js

@@ -9,6 +9,7 @@ import { TaskLoadingScreen } from "../../view/task/TaskLoadingScreen.js";
 import { actionTask } from "../../core/process/task/util/actionTask.js";
 import { delayTask } from "../../core/process/task/util/delayTask.js";
 import { wrapTaskIgnoreFailure } from "../../core/process/task/util/wrapTaskIgnoreFailure.js";
+import { assert } from "../../core/assert.js";
 
 
 /**
@@ -19,7 +20,17 @@ import { wrapTaskIgnoreFailure } from "../../core/process/task/util/wrapTaskIgno
  * @param {string} [name]
  * @return {Promise}
  */
-export function transitionToScene({ tasks = [], scene, engine, name }) {
+export function transitionToScene({
+                                      tasks = [],
+                                      scene,
+                                      engine,
+                                      name
+                                  }) {
+
+    assert.defined(engine, 'engine');
+    assert.defined(scene, 'scene');
+    assert.isArray(tasks, 'tasks');
+
     if (name === undefined) {
         if (tasks.length > 0) {
             //assume name of the first task

package/src/engine/simulation/Ticker.js

@@ -51,7 +51,7 @@ class Ticker {
      * @param {*} [thisArg]
      */
     unsubscribe(callback, thisArg) {
-        assert.typeOf(callback, 'function', 'callback');
+        assert.isFunction(callback, 'callback');
 
         const callbacks = this.callbacks;
         const n = callbacks.length;

package/src/generation/theme/TerrainLayerDescription.js

@@ -17,7 +17,7 @@ export class TerrainLayerDescription {
     }
 
     hash() {
-        return computeStringHash(this.diffuse) ^ this.size.hashCode();
+        return computeStringHash(this.diffuse) ^ this.size.hash();
     }
 
     /**