@woosh/meep-engine 2.51.0 → 2.53.0

package/src/engine/graphics/texture/sampler/filter/filter_lanczos3.js

@@ -5,15 +5,20 @@ export function filter_lanczos3(x) {
     //     x = -x;
     // }
 
-    if (x > 3) {
+    const lobes = 3;
+
+    if (x > lobes) {
         return 0;
     }
 
     if (x < 1.1920929e-7) {
+        // distance is very close to 0
         return 1;
     }
 
-    return (3 * Math.sin(Math.PI * x) * Math.sin(Math.PI * x / 3)) / (Math.PI * Math.PI * x * x);
+    const px = Math.PI * x;
+
+    return (lobes * Math.sin(px) * Math.sin(px / lobes)) / (px * px);
 
 }
 

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/grid2transform/GridPosition2Transform.js

@@ -0,0 +1,122 @@
+import Vector2 from "../../../core/geom/Vector2.js";
+import { GridPosition2TransformFlags } from "./GridPosition2TransformFlags.js";
+
+/**
+ * Created by Alex on 20/01/2015.
+ */
+
+
+const DEFAULT_FLAGS = GridPosition2TransformFlags.Immediate;
+
+export class GridPosition2Transform {
+    constructor() {
+        /**
+         *
+         * @type {Vector2}
+         */
+        this.offset = new Vector2(0, 0);
+
+        /**
+         *
+         * @type {GridPosition2TransformFlags|number}
+         */
+        this.flags = DEFAULT_FLAGS;
+    }
+
+    /**
+     *
+     * @param {number|GridPosition2TransformFlags} flag
+     * @returns {void}
+     */
+    setFlag(flag) {
+        this.flags |= flag;
+    }
+
+    /**
+     *
+     * @param {number|GridPosition2TransformFlags} flag
+     * @returns {void}
+     */
+    clearFlag(flag) {
+        this.flags &= ~flag;
+    }
+
+    /**
+     *
+     * @param {number|GridPosition2TransformFlags} flag
+     * @param {boolean} value
+     */
+    writeFlag(flag, value) {
+        if (value) {
+            this.setFlag(flag);
+        } else {
+            this.clearFlag(flag);
+        }
+    }
+
+    /**
+     *
+     * @param {number|GridPosition2TransformFlags} flag
+     * @returns {boolean}
+     */
+    getFlag(flag) {
+        return (this.flags & flag) === flag;
+    }
+
+    toJSON() {
+        return {
+            offset: this.offset.toJSON()
+        };
+    }
+
+    fromJSON(obj) {
+
+        if (typeof obj.offset === "object") {
+            this.offset.fromJSON(obj.offset);
+        } else {
+            this.offset.set(0, 0);
+        }
+
+    }
+
+    /**
+     *
+     * @param {GridPosition2Transform} other
+     */
+    copy(other) {
+        this.offset.copy(other.offset);
+
+        return this;
+    }
+
+    /**
+     *
+     * @returns {GridPosition2Transform}
+     */
+    clone() {
+        const clone = new GridPosition2Transform();
+
+        clone.copy(this);
+
+        return clone;
+    }
+
+    /**
+     *
+     * @param {GridPosition2Transform} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return this.offset.equals(other.offset);
+    }
+
+    /**
+     * @returns {number}
+     */
+    hash() {
+        return this.offset.hash();
+    }
+
+}
+
+GridPosition2Transform.typeName = "GridPosition2Transform";

package/src/engine/grid/grid2transform/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/grid/grid2transform/GridPosition2TransformSerializationUpgrader_0_1.js

@@ -0,0 +1,40 @@
+import { BinaryClassUpgrader } from "../../ecs/storage/binary/BinaryClassUpgrader.js";
+
+export class GridPosition2TransformSerializationUpgrader_0_1 extends BinaryClassUpgrader {
+    constructor() {
+        super();
+
+        //
+        this.__startVersion = 0;
+        this.__targetVersion = 1;
+    }
+
+    upgrade(source, target) {
+        const offsetX = source.readFloat64();
+        const offsetY = source.readFloat64();
+
+        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;
+        }
+
+        target.writeUint8(header);
+
+        if ((header & 1) !== 0) {
+            //write X
+            target.writeFloat32(offsetX);
+        }
+
+        if ((header & 2) !== 0) {
+            //write Y
+            target.writeFloat32(offsetY);
+        }
+    }
+}

package/src/engine/grid/{systems → grid2transform}/GridPosition2TransformSystem.js

@@ -3,10 +3,10 @@
  */
 import { System } from '../../ecs/System.js';
 import { Transform } from '../../ecs/transform/Transform.js';
-import GridPosition from '../components/GridPosition.js';
-import { GridPosition2Transform } from '../components/GridPosition2Transform.js';
+import GridPosition from '../position/GridPosition.js';
+import { GridPosition2Transform } from './GridPosition2Transform.js';
 import Vector3 from "../../../core/geom/Vector3.js";
-import { GridPosition2TransformFlags } from "../components/GridPosition2TransformFlags.js";
+import { GridPosition2TransformFlags } from "./GridPosition2TransformFlags.js";
 import { obtainTerrain } from "../../ecs/terrain/util/obtainTerrain.js";
 import { ResourceAccessSpecification } from "../../../core/model/ResourceAccessSpecification.js";
 import { ResourceAccessKind } from "../../../core/model/ResourceAccessKind.js";

package/src/engine/grid/{components → obstacle}/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/obstacle/GridObstacle.spec.js

@@ -0,0 +1,175 @@
+import GridObstacle from "./GridObstacle.js";
+
+test('resize 1x1 to 1x2', () => {
+    const g = new GridObstacle();
+
+    g.size.set(1, 1);
+    g.data = [7];
+
+    g.resize(1, 2);
+
+    expect(g.data[0]).toBe(7);
+});
+
+test('resize 1x1 to 2x1', () => {
+    const g = new GridObstacle();
+
+    g.size.set(1, 1);
+    g.data = [7];
+
+    g.resize(2, 1);
+
+    expect(g.data[0]).toBe(7);
+});
+
+
+test('resize 2x1 to 1x1', () => {
+    const g = new GridObstacle();
+
+    g.size.set(2, 1);
+    g.data = [3, 7];
+
+    g.resize(1, 1);
+
+    expect(g.data[0]).toBe(3);
+});
+
+test('resize 1x2 to 1x1', () => {
+    const g = new GridObstacle();
+
+    g.size.set(1, 2);
+    g.data = [3, 7];
+
+    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 → position}/GridPosition.js

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

package/src/engine/grid/{systems → position}/GridPositionSystem.js

@@ -2,7 +2,7 @@
  * Created by Alex on 13/10/2014.
  */
 import { System } from '../../ecs/System.js';
-import GridPosition from '../components/GridPosition.js';
+import GridPosition from './GridPosition.js';
 import { QuadTreeNode } from "../../../core/geom/2d/quad-tree/QuadTreeNode.js";
 
 class GridPositionSystem extends System {

package/src/engine/grid/transform2grid/Transform2GridPositionSystem.js

@@ -1,6 +1,6 @@
 import { System } from "../../ecs/System.js";
 import { Transform2GridPosition } from "./Transform2GridPosition.js";
-import GridPosition from "../components/GridPosition.js";
+import GridPosition from "../position/GridPosition.js";
 import { Transform } from "../../ecs/transform/Transform.js";
 import Vector2 from "../../../core/geom/Vector2.js";
 import { Transform2GridPositionMode } from "./Transform2GridPositionMode.js";