@woosh/meep-engine 2.51.0 → 2.52.0

package/package.json

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

package/src/core/NumberFormat.js

@@ -2,74 +2,3 @@
  * Created by Alex on 08/08/2016.
  * @copyright Alex Goldring 2016
  */
-
-
-import { assert } from "./assert.js";
-
-/**
- *
- * @param {number} x
- * @param {string} [separator]
- * @returns {string}
- */
-function formatNumberByThousands(x, separator) {
-    if (separator === undefined) {
-        separator = ','
-    }
-
-    return x.toString().replace(/\B(?=(\d{3})+(?!\d))/g, separator);
-}
-
-
-/**
- *
- * @param {string} value
- * @returns {number}
- */
-function countDecimals(value) {
-    if (value % 1 === 0) {
-        //whole number
-        return 0;
-    }
-    const s = value.toString();
-    const index = s.indexOf('.');
-
-    if (index === -1) {
-        return 0;
-    }
-
-    //find last 0
-    let endIndex = s.length - 1;
-    for (; endIndex > index && s.charAt(endIndex) === "0"; endIndex--) {
-
-    }
-    const result = endIndex - index;
-    return result;
-}
-
-/**
- *
- * @param {number} value
- * @returns {string|number}
- */
-function prettyPrint(value) {
-    assert.typeOf(value, 'number', 'value');
-
-    const MAX_DECIMALS = 2;
-
-    const fraction = value % 1;
-    if (fraction !== 0 && Math.abs(value) < 100) {
-        const decimals = countDecimals(value.toFixed(MAX_DECIMALS));
-        const decimalsToPrint = Math.min(decimals, MAX_DECIMALS);
-        return value.toFixed(decimalsToPrint);
-    } else {
-        //no fraction
-        return formatNumberByThousands(value - fraction, ",");
-    }
-
-}
-
-export {
-    prettyPrint,
-    formatNumberByThousands
-};

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

@@ -583,6 +583,7 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
      */
     insert_leaf(leaf) {
         assert.isNonNegativeInteger(leaf, 'leaf');
+        assert.equal(this.node_is_leaf(leaf), true, 'not is not a leaf');
 
         let uint32 = this.__data_uint32;
 

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

@@ -0,0 +1,16 @@
+import { BVHQuery } from "./BVHQuery.js";
+
+/**
+ * Accept any node
+ */
+export class BVHQueryAny extends BVHQuery {
+    evaluate(node, tree) {
+        return true;
+    }
+
+    /**
+     * @readonly
+     * @type {BVHQueryAny}
+     */
+    static INSTANCE = new BVHQueryAny();
+}

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

@@ -10,15 +10,15 @@ const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
  * @param {number[]} destination
  * @param {number} destination_offset
  * @param {ExplicitBinaryBoundingVolumeHierarchy} bvh
- * @param {number} node
+ * @param {number} root
  * @returns {number} number of collected elements
  */
 export function bvh_collect_user_data(
     destination, destination_offset,
-    bvh, node
+    bvh, root
 ) {
 
-    if (node === NULL_NODE) {
+    if (root === NULL_NODE) {
         return 0;
     }
 
@@ -28,7 +28,7 @@ export function bvh_collect_user_data(
      */
     const stack_top = stack.pointer++;
 
-    stack[stack_top] = node;
+    stack[stack_top] = root;
 
     let result_cursor = destination_offset;
 
@@ -54,7 +54,7 @@ export function bvh_collect_user_data(
             stack[stack.pointer++] = child2;
 
         } else {
-            // leaf node
+            // leaf root
 
             destination[result_cursor++] = bvh.node_get_user_data(node);
         }

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

@@ -8,16 +8,15 @@ const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
  * @param {ExplicitBinaryBoundingVolumeHierarchy} bvh
  * @param {number[]} result
  * @param {number} result_offset
+ * @param {number} root
  * @param {BVHQuery} query
  * @returns {number}
  */
 export function bvh_query_leaves_generic(
     result, result_offset,
-    bvh, query
+    bvh, root, query
 ) {
 
-    const root = bvh.root;
-
     if (root === NULL_NODE) {
         return 0;
     }

package/src/core/bvh2/bvh3/query/bvh_query_leaves_generic.spec.js

@@ -0,0 +1,22 @@
+import { ExplicitBinaryBoundingVolumeHierarchy } from "../ExplicitBinaryBoundingVolumeHierarchy.js";
+import { bvh_query_leaves_generic } from "./bvh_query_leaves_generic.js";
+import { BVHQueryAny } from "./BVHQueryAny.js";
+
+test("all-accepting query", () => {
+    const bvh = new ExplicitBinaryBoundingVolumeHierarchy();
+
+    const leaf_a = bvh.allocate_node();
+    const leaf_b = bvh.allocate_node();
+
+    bvh.insert_leaf(leaf_a);
+    bvh.insert_leaf(leaf_b);
+
+    const result = [];
+
+    const count = bvh_query_leaves_generic(result, 1, bvh, bvh.root, BVHQueryAny.INSTANCE);
+
+    expect(count).toBe(2);
+    expect(result).toContain(leaf_a);
+    expect(result).toContain(leaf_b);
+
+});

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

@@ -13,6 +13,7 @@ const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
 /**
  *
  * @param {ExplicitBinaryBoundingVolumeHierarchy} bvh
+ * @param {number} root
  * @param {number[]} result
  * @param {number} result_offset
  * @param {number} origin_x
@@ -24,12 +25,11 @@ const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
  * @returns {number}
  */
 export function bvh_query_leaves_ray(
-    bvh,
+    bvh, root,
     result, result_offset,
     origin_x, origin_y, origin_z,
     direction_x, direction_y, direction_z
 ) {
-    const root = bvh.root;
 
     if (root === NULL_NODE) {
         return 0;

package/src/core/bvh2/bvh3/query/bvh_query_leaves_ray.spec.js

@@ -0,0 +1,64 @@
+import { ExplicitBinaryBoundingVolumeHierarchy } from "../ExplicitBinaryBoundingVolumeHierarchy.js";
+import { bvh_query_leaves_ray } from "./bvh_query_leaves_ray.js";
+
+/**
+ *
+ * @param {number[]} leaves
+ */
+function makeBVH(...leaves) {
+
+    const bvh = new ExplicitBinaryBoundingVolumeHierarchy();
+
+    for (let i = 0; i < leaves.length; i++) {
+
+        const node = bvh.allocate_node();
+
+        bvh.node_set_aabb(node, leaves[i]);
+        bvh.node_set_user_data(node, i);
+
+        bvh.insert_leaf(node);
+    }
+
+    return bvh;
+}
+
+test("cast positive -X to +X, 1 node", () => {
+
+    const bvh = makeBVH(
+        [1, 3, 5, 7, 11, 13]
+    );
+
+    const result = [];
+
+    const match_count = bvh_query_leaves_ray(
+        bvh, bvh.root,
+        result, 0,
+        -1, 4, 6,
+        1, 0, 0
+    );
+
+    expect(match_count).toBe(1);
+
+    expect(result[0]).toEqual(0);
+});
+
+test("cast positive -X to +X, 1/2 nodes", () => {
+
+    const bvh = makeBVH(
+        [-4, 3, 5, -2, 11, 13],
+        [1, 3, 5, 7, 11, 13]
+    );
+
+    const result = [];
+
+    const match_count = bvh_query_leaves_ray(
+        bvh, bvh.root,
+        result, 0,
+        -1, 4, 6,
+        1, 0, 0
+    );
+
+    expect(match_count).toBe(1);
+
+    expect(result[0]).toEqual(1);
+});

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

@@ -9,16 +9,15 @@ const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
  * @param {ExplicitBinaryBoundingVolumeHierarchy} bvh
  * @param {number[]} result
  * @param {number} result_offset
+ * @param {number} root
  * @param {BVHQuery} query
  * @returns {number}
  */
 export function bvh_query_user_data_generic(
     result, result_offset,
-    bvh, query
+    bvh,root, query
 ) {
 
-    const root = bvh.root;
-
     if (root === NULL_NODE) {
         return 0;
     }

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

@@ -0,0 +1,41 @@
+import { assert } from "../../../assert.js";
+
+/**
+ *
+ * @param {number[]|ArrayLike<number>|Float32Array} result
+ * @param {BufferGeometry} geometry
+ */
+export function aabb3_from_threejs_geometry(result, geometry) {
+    const gbb = geometry.boundingBox;
+
+    assert.notNull(gbb, 'boundingBox');
+
+    const min = gbb.min;
+    const max = gbb.max;
+
+    const x0 = min.x;
+    const y0 = min.y;
+    const z0 = min.z;
+
+    const x1 = max.x;
+    const y1 = max.y;
+    const z1 = max.z;
+
+    // validate bounds
+    assert.notNaN(x0, 'x0');
+    assert.notNaN(y0, 'y0');
+    assert.notNaN(z0, 'z0');
+
+    assert.notNaN(x1, 'x1');
+    assert.notNaN(y1, 'y1');
+    assert.notNaN(z1, 'z1');
+
+    // marshal into transform-accepted format
+    result[0] = x0;
+    result[1] = y0;
+    result[2] = z0;
+
+    result[3] = x1;
+    result[4] = y1;
+    result[5] = z1;
+}

package/src/core/geom/3d/topology/struct/TopoMesh.js

@@ -8,7 +8,8 @@ import { tm_kill_only_vert } from "../tm_kill_only_vert.js";
 import { tm_kill_only_edge } from "../tm_kill_only_edge.js";
 import { tm_kill_only_face } from "../tm_kill_only_face.js";
 import { query_edge_other_vertex } from "../query/query_edge_other_vertex.js";
-import { formatNumberByThousands } from "../../../../NumberFormat.js";
+
+import { number_format_by_thousands } from "../../../../primitives/numbers/number_format_by_thousands.js";
 
 export class TopoMesh {
     constructor() {
@@ -643,7 +644,7 @@ export class TopoMesh {
     }
 
     toString() {
-        return `TopoMesh{ vertices: ${formatNumberByThousands(this.vertices.length)}, edges: ${formatNumberByThousands(this.getEdges().size)}, faces: ${formatNumberByThousands(this.getFaces().size)} }`;
+        return `TopoMesh{ vertices: ${number_format_by_thousands(this.vertices.length)}, edges: ${number_format_by_thousands(this.getEdges().size)}, faces: ${number_format_by_thousands(this.getFaces().size)} }`;
     }
 }
 

package/src/core/geom/3d/topology/struct/prototypeBinaryTopology.js

@@ -5,8 +5,8 @@ import { BinaryTopology } from "./binary/BinaryTopology.js";
 import {
     compute_buffer_geometry_byte_size
 } from "../../../../../engine/graphics/geometry/buffered/compute_buffer_geometry_byte_size.js";
-import { prettyPrint } from "../../../../NumberFormat.js";
 import { TopoMesh } from "./TopoMesh.js";
+import { number_pretty_print } from "../../../../primitives/numbers/number_pretty_print.js";
 
 function promise_ply(url) {
 
@@ -44,9 +44,9 @@ async function main() {
 
     console.log(mesh, lucy_geom);
 
-    console.log(`source mesh size: ${prettyPrint(compute_buffer_geometry_byte_size(lucy_geom))} bytes`);
-    console.log(`binary topology size: ${prettyPrint(mesh.byteSize)} bytes`);
-    console.log(`object topology size: ${prettyPrint(topoMesh.byteSize)} bytes`);
+    console.log(`source mesh size: ${number_pretty_print(compute_buffer_geometry_byte_size(lucy_geom))} bytes`);
+    console.log(`binary topology size: ${number_pretty_print(mesh.byteSize)} bytes`);
+    console.log(`object topology size: ${number_pretty_print(topoMesh.byteSize)} bytes`);
 
     window.topo_obj = topoMesh;
 }

package/src/core/geom/Vector2.d.ts

@@ -23,6 +23,8 @@ export default class Vector2 {
 
     _sub(x: number, y: number): void
 
+    lerpVectors(a: Vector2, b: Vector2, f: number): void
+
     abs(): void
 
     round(): void
@@ -31,6 +33,8 @@ export default class Vector2 {
 
     ceil(): void
 
+    rotate(angle: number): void
+
     copy(other: Vector2): void
 
     clone(): Vector2
@@ -39,8 +43,13 @@ export default class Vector2 {
 
     roughlyEquals(other: Vector2, tolerance?: number): boolean
 
+    hash(): number
+
     distanceTo(other: Vector2): number
 
+    manhattanDistanceTo(other: Vector2): number
+
+
     isZero(): boolean
 
     readFromArray(array: ArrayLike<number>, offset?: number): void

package/src/core/geom/Vector2.js

@@ -450,7 +450,10 @@ class Vector2 {
      * @param {number} fraction
      */
     lerpVectors(a, b, fraction) {
-        v2Lerp(this, a, b, fraction);
+        const x = lerp(a.x, b.x, fraction);
+        const y = lerp(a.y, b.y, fraction);
+
+        this.set(x, y);
     }
 
     /**
@@ -538,7 +541,7 @@ class Vector2 {
      *
      * @returns {number}
      */
-    hashCode() {
+    hash() {
         const x = Math.sin(this.x) * 1367130550;
         const y = Math.sin(this.y) * 1367130550;
 
@@ -550,7 +553,7 @@ class Vector2 {
     }
 
     /**
-     *
+     * Rotation is counter-clockwise
      * @param {number} angle in radians
      */
     rotate(angle) {
@@ -558,7 +561,7 @@ class Vector2 {
         const cos = Math.cos(angle);
 
         const x = this.x * cos - this.y * sin
-        const y = this.x * sin - this.y * cos;
+        const y = this.x * sin + this.y * cos;
 
         this.set(x, y);
     }
@@ -597,7 +600,7 @@ class Vector2 {
      * @return {boolean}
      */
     roughlyEquals(other, tolerance) {
-        return this._roughlyEquals(other.x, other.y,  tolerance);
+        return this._roughlyEquals(other.x, other.y, tolerance);
     }
 
     /**
@@ -677,23 +680,6 @@ Vector2.one = Object.freeze(new Vector2(1, 1));
  * @type {boolean}
  */
 Vector2.prototype.isVector2 = true;
-
-/**
- *
- * @param {Vector2} result
- * @param {Vector2} a
- * @param {Vector2} b
- * @param {number} fraction
- */
-function v2Lerp(result, a, b, fraction) {
-
-    const x = lerp(a.x, b.x, fraction);
-    const y = lerp(a.y, b.y, fraction);
-
-    result.set(x, y);
-}
-
-
 /**
  *
  * @param {number} x0

package/src/core/geom/Vector2.spec.js

@@ -8,6 +8,21 @@ test("setting x and y via constructor", () => {
     expect(v.y).toBe(13);
 });
 
+test("array-style accessors", () => {
+
+    const v = new Vector2();
+
+    v[0] = 3;
+    v[1] = -7;
+
+    expect(v[0]).toEqual(3);
+    expect(v.x).toEqual(3);
+
+    expect(v[1]).toEqual(-7);
+    expect(v.y).toEqual(-7);
+
+});
+
 test('add works', () => {
     const a = new Vector2(1, 3);
     const b = new Vector2(5, 7);
@@ -140,3 +155,141 @@ test("onChange is dispatched when y changes via set", () => {
 
     expect(changeHandler).toHaveBeenLastCalledWith(2, 3, 1, 3);
 });
+
+test("rotate", () => {
+
+    const v = new Vector2(0, 0);
+
+    v.rotate(0);
+
+    expect(v.x).toBeCloseTo(0);
+    expect(v.y).toBeCloseTo(0);
+
+    v.set(1, 0);
+
+    v.rotate(0);
+
+    expect(v.x).toBeCloseTo(1);
+    expect(v.y).toBeCloseTo(0);
+
+    v.set(0, 1);
+
+    v.rotate(0);
+
+    expect(v.x).toBeCloseTo(0);
+    expect(v.y).toBeCloseTo(1);
+
+    v.set(1, 0);
+
+    v.rotate(Math.PI);
+
+    expect(v.x).toBeCloseTo(-1);
+    expect(v.y).toBeCloseTo(0);
+
+    v.set(-1, 0);
+
+    v.rotate(Math.PI);
+
+    expect(v.x).toBeCloseTo(1);
+    expect(v.y).toBeCloseTo(0);
+
+    v.set(0, 1);
+
+    v.rotate(Math.PI);
+
+    expect(v.x).toBeCloseTo(0);
+    expect(v.y).toBeCloseTo(-1);
+
+    v.set(0, -1);
+
+    v.rotate(Math.PI);
+
+    expect(v.x).toBeCloseTo(0);
+    expect(v.y).toBeCloseTo(1);
+
+    v.set(1, 1);
+
+    v.rotate(Math.PI * 0.5);
+
+    expect(v.x).toBeCloseTo(-1);
+    expect(v.y).toBeCloseTo(1);
+});
+
+test("hash", () => {
+
+    function validate(x, y) {
+
+        const v = new Vector2(x, y);
+
+        const hash = v.hash();
+
+        expect(hash).toEqual(v.hash()); // stability
+        expect(typeof hash).toBe("number");
+        expect(Number.isInteger(hash)).toBe(true);
+
+    }
+
+    validate(0, 0);
+    validate(0, 1);
+    validate(1, 0);
+    validate(1, 1);
+
+    validate(0, -1);
+    validate(-1, 0);
+    validate(-1, -1);
+});
+
+test("normalize", () => {
+
+    const v = new Vector2(1, 1);
+
+    v.normalize();
+
+    const s = 1 / Math.SQRT2;
+
+    expect(v.x).toBeCloseTo(s);
+    expect(v.y).toBeCloseTo(s);
+
+    v.set(-1, -1);
+
+    v.normalize();
+
+    expect(v.x).toBeCloseTo(-s);
+    expect(v.y).toBeCloseTo(-s);
+
+});
+
+test("length", () => {
+
+    expect(new Vector2(1, 0).length()).toBeCloseTo(1);
+    expect(new Vector2(0, 1).length()).toBeCloseTo(1);
+
+    expect(new Vector2(1, 1).length()).toBeCloseTo(Math.SQRT2);
+
+    expect(new Vector2(-1, 1).length()).toBeCloseTo(Math.SQRT2);
+
+    expect(new Vector2(1, -1).length()).toBeCloseTo(Math.SQRT2);
+
+    expect(new Vector2(-1, -1).length()).toBeCloseTo(Math.SQRT2);
+});
+
+
+test("manhattanDistanceTo", () => {
+    const a = new Vector2(1, 3);
+    const b = new Vector2(5, 11);
+
+    expect(a.manhattanDistanceTo(b)).toEqual(12)
+});
+
+test("lerpVectors", () => {
+
+
+    const a = new Vector2(-1, 3);
+    const b = new Vector2(5, -11);
+
+    a.lerpVectors(a, b, 0.1);
+
+    expect(a.x).toBeCloseTo(-1 * 0.9 + 5 * 0.1);
+    expect(a.y).toBeCloseTo(3 * 0.9 - 11 * 0.1);
+
+});

package/src/core/model/ModuleRegistry.js

@@ -15,9 +15,7 @@ export class ModuleRegistry {
 
     constructor() {
 
-        const self = this;
-
-        this.proxy = new Proxy({}, {
+        this.proxy = new Proxy(this, {
             /**
              *
              * @param target
@@ -26,7 +24,7 @@ export class ModuleRegistry {
              * @returns {Class}
              */
             get(target, p, receiver) {
-                const module = self.get(p);
+                const module = target.get(p);
 
                 if (module === undefined) {
                     throw new Error(`Module '${p}' not found in the registry`);

package/src/core/model/ModuleRegistry.spec.js

@@ -0,0 +1,31 @@
+import { ModuleRegistry } from "./ModuleRegistry.js";
+
+test("constructor does not throw", () => {
+
+    expect(() => new ModuleRegistry()).not.toThrow();
+
+});
+
+test("add/retrieve", () => {
+
+    const registry = new ModuleRegistry();
+
+    const module = {};
+
+    registry.add("x", module);
+
+    expect(registry.get("x")).toBe(module);
+
+});
+
+test("retrieve by proxy", () => {
+
+    const registry = new ModuleRegistry();
+
+    const module = {};
+
+    registry.add("x", module);
+
+    expect(registry.proxy.x).toBe(module);
+
+});