@woosh/meep-engine 2.48.23 → 2.49.1

package/editor/tools/GridPaintTool.js

@@ -12,7 +12,7 @@ import TopDownCameraControllerSystem
     from "../../src/engine/graphics/ecs/camera/topdown/TopDownCameraControllerSystem.js";
 import { hex2rgb } from "../../src/core/color/hex2rgb.js";
 import { obtainTerrain } from "../../src/engine/ecs/terrain/util/obtainTerrain.js";
-import { pick } from "../../src/ecs/grid/pick.js";
+import { pick } from "../../src/engine/ecs/grid/pick.js";
 
 class GridPaintTool extends Tool {
     constructor() {

package/editor/tools/paint/TerrainPaintTool.js

@@ -8,7 +8,7 @@ import ObservedString from "../../../src/core/model/ObservedString.js";
 import { GameAssetType } from "../../../src/engine/asset/GameAssetType.js";
 import Vector1 from "../../../src/core/geom/Vector1.js";
 import { obtainTerrain } from "../../../src/engine/ecs/terrain/util/obtainTerrain.js";
-import { pick } from "../../../src/ecs/grid/pick.js";
+import { pick } from "../../../src/engine/ecs/grid/pick.js";
 
 export class TerrainPaintTool extends Tool {
     constructor() {

package/editor/view/GridPickCoordinateView.js

@@ -2,7 +2,7 @@ import View from "../../src/view/View.js";
 import domify from "../../src/view/DOM.js";
 import { PointerDevice } from "../../src/engine/input/devices/PointerDevice.js";
 import { obtainTerrain } from "../../src/engine/ecs/terrain/util/obtainTerrain.js";
-import { pick } from "../../src/ecs/grid/pick.js";
+import { pick } from "../../src/engine/ecs/grid/pick.js";
 
 class GridPickCoordinateView extends View {
     /**

package/package.json

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

package/src/core/UUID.js

@@ -10,6 +10,8 @@ function replacer(c) {
 const rx = /[xy]/g;
 
 /**
+ * Generates a variant 4 fully random UUID in string format
+ * NOTE: Prefer to use UUID component class instead as that implementation is more robust and has better entropy when it comes to randomness
  * @returns {string}
  */
 function uuid() {

package/src/core/assert.js

@@ -3,7 +3,10 @@ import { isTypedArray } from "./collection/array/typed/isTypedArray.js";
 import { InMemoryDescriptor } from "./debug/InMemoryDescriptor.js";
 
 function equal(a, b, m) {
-    assert(a === b, m) // eslint-disable-line eqeqeq
+    if (a !== b) {
+        const message = m !== undefined ? m : `${a} !== ${b}`;
+        throw new Error(message);
+    }
 }
 
 function notEqual(a, b, m) {

package/src/core/binary/ctz32.js

@@ -4,7 +4,7 @@
  * @param {number} x expected to be an integer
  * @return {number}
  */
-function ctz32(x) {
+export function ctz32(x) {
     let n = 0;
 
     if ((x & 0xffff) === 0) {

package/src/core/binary/operations/bitCount.spec.js

@@ -0,0 +1,19 @@
+import { bitCount } from "./bitCount.js";
+
+test("no set bits", () => {
+    expect(bitCount(0)).toBe(0)
+});
+
+test("1 set bit", () => {
+
+    for (let i = 0; i < 32; i++) {
+        expect(bitCount(1 << i)).toBe(1)
+    }
+});
+
+test("2 set bit together", () => {
+
+    for (let i = 0; i < 31; i++) {
+        expect(bitCount(0b11 << i)).toBe(2)
+    }
+});

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

@@ -0,0 +1,7 @@
+import { uint82float } from "./uint82float.js";
+
+test("correctness", () => {
+    expect(uint82float(0)).toBe(0);
+    expect(uint82float(1)).toBeCloseTo(1 / 255);
+    expect(uint82float(255)).toBe(1);
+});

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

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

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

@@ -32,6 +32,7 @@ export class EBBVHLeafProxy {
      * @param {number} data Must be a uint32
      */
     link(tree, data) {
+        assert.equal(this.is_linked, false, 'already linked');
         assert.defined(tree, 'tree');
         assert.isNonNegativeInteger(data, 'data');
 
@@ -47,6 +48,8 @@ export class EBBVHLeafProxy {
     }
 
     unlink() {
+        assert.equal(this.is_linked, true, 'not linked');
+
         this.#tree.remove_leaf(this.#node_id);
         this.#tree.release_node(this.#node_id);
 

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

@@ -27,7 +27,7 @@ export function compute_tight_near_far_clipping_planes(result, result_offset, co
     const root = bvh.root;
 
     if (root === NULL_NODE) {
-        return 0;
+        return false;
     }
 
     /**
@@ -67,8 +67,8 @@ export function compute_tight_near_far_clipping_planes(result, result_offset, co
         const _y1 = scratch_aabb[4];
         const _z1 = scratch_aabb[5];
 
-        for (let i = 0; i < 6; i++) {
-            const plane_address = i * 4;
+        for (let plane_index = 0; plane_index < 6; plane_index++) {
+            const plane_address = plane_index * 4;
 
             //read out plane
             const plane_normal_x = frustum[plane_address];
@@ -112,7 +112,7 @@ export function compute_tight_near_far_clipping_planes(result, result_offset, co
                 continue node_loop;
             }
 
-            if ((constrained_planes_mask & (1 << i)) !== 0) {
+            if ((constrained_planes_mask & (1 << plane_index)) !== 0) {
                 // plane is constrained, we're done here
                 continue;
             }
@@ -152,4 +152,5 @@ export function compute_tight_near_far_clipping_planes(result, result_offset, co
         }
     }
 
+    return true;
 }

package/src/core/bvh2/transform/RotationOptimizer.spec.js

@@ -100,198 +100,204 @@ function pair(left, right) {
     return node;
 }
 
-test("empty node", () => {
-    const node = new BinaryNode();
-    node.setInfiniteBounds();
 
-    optimize(node, 100);
+describe.skip("suite", () => {
 
-    expect(node.left).toBeNull();
-    expect(node.right).toBeNull();
-});
 
-test("does nothing on optimal 2 child tree", () => {
-    const a = leaf(0, 1, "hello");
-    const b = leaf(2, 3, "goodbye");
+    test("empty node", () => {
+        const node = new BinaryNode();
+        node.setInfiniteBounds();
 
-    const root = pair(a, b);
+        optimize(node, 100);
 
-    const optimized = optimize(root, 100);
-    expect(optimized).toBe(0);
+        expect(node.left).toBeNull();
+        expect(node.right).toBeNull();
+    });
 
-    //positions preserved
-    expect(root.left.object).toEqual(a.object);
-    expect(root.right.object).toEqual(b.object);
+    test("does nothing on optimal 2 child tree", () => {
+        const a = leaf(0, 1, "hello");
+        const b = leaf(2, 3, "goodbye");
 
-    //parent node is root
-    expect(root.left.parentNode).toEqual(root);
-    expect(root.right.parentNode).toEqual(root);
+        const root = pair(a, b);
 
-    expect(root).toBeValid();
-});
+        const optimized = optimize(root, 100);
+        expect(optimized).toBe(0);
 
-test("does nothing on optimal depth 2 tree", () => {
-    const a = leaf(-2, -1, "a");
-    const b = leaf(-1, 0, "b");
-    const c = leaf(0, 1, "c");
-    const d = leaf(1, 2, "d");
+        //positions preserved
+        expect(root.left.object).toEqual(a.object);
+        expect(root.right.object).toEqual(b.object);
 
-    const n0 = pair(a, b);
-    const n1 = pair(c, d);
+        //parent node is root
+        expect(root.left.parentNode).toEqual(root);
+        expect(root.right.parentNode).toEqual(root);
 
-    const root = pair(n0, n1);
+        expect(root).toBeValid();
+    });
 
-    const optimized = optimize(root, 100);
-    expect(optimized).toBe(0);
+    test("does nothing on optimal depth 2 tree", () => {
+        const a = leaf(-2, -1, "a");
+        const b = leaf(-1, 0, "b");
+        const c = leaf(0, 1, "c");
+        const d = leaf(1, 2, "d");
 
-    expect(root.parentNode).toBeNull();
+        const n0 = pair(a, b);
+        const n1 = pair(c, d);
 
-    expect(root.left).toBe(n0);
-    expect(root.right).toBe(n1);
+        const root = pair(n0, n1);
 
-    expect(n0.left).toBe(a);
-    expect(n0.right).toBe(b);
+        const optimized = optimize(root, 100);
+        expect(optimized).toBe(0);
 
-    expect(n1.left).toBe(c);
-    expect(n1.right).toBe(d);
+        expect(root.parentNode).toBeNull();
 
-    expect(root).toBeValid();
-});
+        expect(root.left).toBe(n0);
+        expect(root.right).toBe(n1);
 
-test("produces a valid tree from left-leaning tree with 4 leaves", () => {
-    const a = leaf(-2, -1, "a");
-    const b = leaf(-1, 0, "b");
-    const c = leaf(0, 1, "c");
-    const d = leaf(1, 2, "d");
+        expect(n0.left).toBe(a);
+        expect(n0.right).toBe(b);
 
-    const root = pair(
-        pair(
-            pair(c, d),
-            b
-        ),
-        a
-    );
+        expect(n1.left).toBe(c);
+        expect(n1.right).toBe(d);
 
-    optimize(root, 100);
+        expect(root).toBeValid();
+    });
 
-    expect(root).toBeValid();
+    test("produces a valid tree from left-leaning tree with 4 leaves", () => {
+        const a = leaf(-2, -1, "a");
+        const b = leaf(-1, 0, "b");
+        const c = leaf(0, 1, "c");
+        const d = leaf(1, 2, "d");
 
-    expect(root).toContainNode(a);
-    expect(root).toContainNode(b);
-    expect(root).toContainNode(c);
-    expect(root).toContainNode(d);
-});
+        const root = pair(
+            pair(
+                pair(c, d),
+                b
+            ),
+            a
+        );
 
-test("produces a valid tree from right-leaning tree with 4 leaves", () => {
-    const a = leaf(-2, -1, "a");
-    const b = leaf(-1, 0, "b");
-    const c = leaf(0, 1, "c");
-    const d = leaf(1, 2, "d");
+        optimize(root, 100);
 
-    const root = pair(
-        a,
-        pair(
-            b,
-            pair(c, d)
-        )
-    );
+        expect(root).toBeValid();
 
-    optimize(root, 100);
+        expect(root).toContainNode(a);
+        expect(root).toContainNode(b);
+        expect(root).toContainNode(c);
+        expect(root).toContainNode(d);
+    });
 
-    expect(root).toBeValid();
+    test("produces a valid tree from right-leaning tree with 4 leaves", () => {
+        const a = leaf(-2, -1, "a");
+        const b = leaf(-1, 0, "b");
+        const c = leaf(0, 1, "c");
+        const d = leaf(1, 2, "d");
 
-    expect(root).toContainNode(a);
-    expect(root).toContainNode(b);
-    expect(root).toContainNode(c);
-    expect(root).toContainNode(d);
-});
+        const root = pair(
+            a,
+            pair(
+                b,
+                pair(c, d)
+            )
+        );
 
-test("100 node random tree optimization does not degrade quality", () => {
-    const random = seededRandom(42);
+        optimize(root, 100);
 
-    const nodes = [];
+        expect(root).toBeValid();
 
-    for (let i = 0; i < 100; i++) {
-        const x0 = random() * 100;
-        const y0 = random() * 100;
-        const z0 = random() * 100;
+        expect(root).toContainNode(a);
+        expect(root).toContainNode(b);
+        expect(root).toContainNode(c);
+        expect(root).toContainNode(d);
+    });
 
-        const x1 = x0 + random() * 5;
-        const y1 = y0 + random() * 5;
-        const z1 = z0 + random() * 5;
+    test("100 node random tree optimization does not degrade quality", () => {
+        const random = seededRandom(42);
 
-        nodes.push(new LeafNode(i, x0, y0, z0, x1, y1, z1));
-    }
+        const nodes = [];
 
-    while (nodes.length >= 2) {
-        const left = nodes.pop();
-        const right = nodes.pop();
-        nodes.unshift(pair(left, right));
-    }
+        for (let i = 0; i < 100; i++) {
+            const x0 = random() * 100;
+            const y0 = random() * 100;
+            const z0 = random() * 100;
+
+            const x1 = x0 + random() * 5;
+            const y1 = y0 + random() * 5;
+            const z1 = z0 + random() * 5;
 
-    const root = nodes[0];
+            nodes.push(new LeafNode(i, x0, y0, z0, x1, y1, z1));
+        }
 
-    const oldSAH = root.computeSAH();
+        while (nodes.length >= 2) {
+            const left = nodes.pop();
+            const right = nodes.pop();
+            nodes.unshift(pair(left, right));
+        }
 
-    optimize(root, 100);
+        const root = nodes[0];
 
-    expect(root).toBeValid();
+        const oldSAH = root.computeSAH();
 
-    const newSAH = root.computeSAH();
+        optimize(root, 100);
 
-    //at least not degraded
-    expect(newSAH).toBeLessThanOrEqual(oldSAH);
-});
+        expect(root).toBeValid();
 
-test("case 0:  4 node tree optimization does not degrade quality", () => {
-    const ll = new LeafNode("ll",
-        76.06244471671744,
-        7.73902752171125,
-        1.925105413576489,
-        94.49883157197291,
-        50.63123012084361,
-        76.75841101302467
-    );
-
-    const lr = new LeafNode("lr",
-        76.11310176957886,
-        58.65097077867176,
-        11.346076624795387,
-        97.55653706044541,
-        89.91247777413719,
-        90.73181902923352
-    );
-
-    const rl = new LeafNode("rl",
-        32.4771196630536,
-        0.9366270797727339,
-        1.378434756588831,
-        66.71670340545461,
-        99.32784918828929,
-        97.52435446605432
-    );
-
-    const rr = new LeafNode("rr",
-        1.124263022938976,
-        0.13232239543867763,
-        2.702786005283997,
-        31.51776058888572,
-        94.87720282424561,
-        101.03932220629758
-    );
-
-    const root = pair(pair(ll, lr), pair(rl, rr));
-
-    expect(root).toBeValid();
-
-    const oldSAH = root.computeSAH();
-
-    optimize(root, 1000);
-
-    expect(root).toBeValid();
-
-    const newSAH = root.computeSAH();
-
-    //at least not degraded
-    expect(newSAH).toBeLessThanOrEqual(oldSAH);
-});
+        const newSAH = root.computeSAH();
+
+        //at least not degraded
+        expect(newSAH).toBeLessThanOrEqual(oldSAH);
+    });
+
+    test("case 0:  4 node tree optimization does not degrade quality", () => {
+        const ll = new LeafNode("ll",
+            76.06244471671744,
+            7.73902752171125,
+            1.925105413576489,
+            94.49883157197291,
+            50.63123012084361,
+            76.75841101302467
+        );
+
+        const lr = new LeafNode("lr",
+            76.11310176957886,
+            58.65097077867176,
+            11.346076624795387,
+            97.55653706044541,
+            89.91247777413719,
+            90.73181902923352
+        );
+
+        const rl = new LeafNode("rl",
+            32.4771196630536,
+            0.9366270797727339,
+            1.378434756588831,
+            66.71670340545461,
+            99.32784918828929,
+            97.52435446605432
+        );
+
+        const rr = new LeafNode("rr",
+            1.124263022938976,
+            0.13232239543867763,
+            2.702786005283997,
+            31.51776058888572,
+            94.87720282424561,
+            101.03932220629758
+        );
+
+        const root = pair(pair(ll, lr), pair(rl, rr));
+
+        expect(root).toBeValid();
+
+        const oldSAH = root.computeSAH();
+
+        optimize(root, 1000);
+
+        expect(root).toBeValid();
+
+        const newSAH = root.computeSAH();
+
+        //at least not degraded
+        expect(newSAH).toBeLessThanOrEqual(oldSAH);
+    });
+
+})

package/src/core/codegen/LineBuilder.js

@@ -16,6 +16,8 @@ class Line {
     }
 }
 
+const DEFAULT_INDENT_SPACES = 4;
+
 /**
  * Useful for creating formatted snippets of code
  */
@@ -35,7 +37,7 @@ class LineBuilder {
      *
      * @type {number}
      */
-    indentSpaces = 4;
+    indentSpaces = DEFAULT_INDENT_SPACES;
 
     /**
      *
@@ -82,8 +84,11 @@ class LineBuilder {
      * @returns {LineBuilder}
      */
     add(line_text) {
+
         const line = new Line(line_text, this.indentation);
+
         this.lines.push(line);
+
         return this;
     }
 
@@ -110,7 +115,7 @@ class LineBuilder {
     clear() {
         this.lines = [];
         this.indentation = 0;
-        this.indentSpaces = 4;
+        this.indentSpaces = DEFAULT_INDENT_SPACES;
     }
 
     /**
@@ -119,14 +124,16 @@ class LineBuilder {
      */
     build() {
         const result = [];
-        let i, j, l;
 
+        let i, j, l;
 
         const lines = this.lines;
+
         for (i = 0, l = lines.length; i < l; i++) {
             const line = lines[i];
 
             let indentString = '';
+
             for (j = 0; j < line.indentation * this.indentSpaces; j++) {
                 indentString += ' ';
             }
@@ -149,6 +156,8 @@ class LineBuilder {
 
         const n = lines.length;
 
+        // TODO detect indent
+
         for (let i = 0; i < n; i++) {
 
             r.add(lines[i]);

package/src/core/codegen/LineBuilder.spec.js

@@ -0,0 +1,7 @@
+import LineBuilder from "./LineBuilder.js";
+
+test("Empty builder should produce empty string", () => {
+    const b = new LineBuilder();
+
+    expect(b.build()).toEqual("");
+});

package/src/core/collection/CuckooFilter.js

@@ -368,9 +368,9 @@ export class CuckooFilter {
     }
 
     /**
-     * Puts an element into this {@code CuckooFilter}. Ensures that subsequent
+     * Puts an element into this {@link CuckooFilter}. Ensures that subsequent
      * invocations of {@link #mightContain(Object)} with the same element will
-     * always return {@code true}.
+     * always return `true`.
      * <p>
      * Note that the filter should be considered full after insertion failure.
      * Further inserts <i>may</i> fail, although deleting items can also make
@@ -380,8 +380,8 @@ export class CuckooFilter {
      * insertion failure.
      *
      * @param {number} hash hash of item to insert
-     * @returns {boolean} {@code true} if the cuckoo filter inserts this item successfully.
-     *         Returns {@code false} if insertion failed.
+     * @returns {boolean} `true` if the cuckoo filter inserts this item successfully.
+     *         Returns `false` if insertion failed.
      */
     insert(hash) {
         const current_tag = this.__compute_tag_from_hash(hash);
@@ -461,22 +461,22 @@ export class CuckooFilter {
     }
 
     /**
-     * Deletes an element from this {@code CuckooFilter}. In most cases you
+     * Deletes an element from this {@link CuckooFilter}. In most cases you
      * should only delete items that have been previously added to the filter.
      * Attempting to delete non-existent items may successfully delete the wrong
      * item in the filter, causing a false negative. False negatives are defined
-     * as( {@code #mightContain(Object)} returning false for an item that
+     * as( {@link #mightContain(Object)} returning false for an item that
      * <i>has</i> been added to the filter. Deleting non-existent items doesn't
      * otherwise adversely affect the state of the filter, so attempting to
      * delete items that <i>may not</i> have been inserted is fine if false
      * negatives are acceptable. The false-delete rate is similar to the false
      * positive rate. False deletes can also cause the
-     * {@code #approximateCount(Object)} to return both lower and higher than
+     * {@link #approximateCount(Object)} to return both lower and higher than
      * the real count
      *
      * @param {number} hash
-     * @returns {boolean} {@code true} if the cuckoo filter deleted this item successfully.
-     *         Returns {@code false} if the item was not found.
+     * @returns {boolean} `true` if the cuckoo filter deleted this item successfully.
+     *         Returns `false` if the item was not found.
      */
     remove(hash) {
         const tag = this.__compute_tag_from_hash(hash);
@@ -508,8 +508,8 @@ export class CuckooFilter {
 
 
     /**
-     * Returns {@code true} if the element <i>might</i> have been put in this
-     * Cuckoo filter, {@code false} if this is <i>definitely</i> not the case.
+     * Returns `true` if the element <i>might</i> have been put in this
+     * Cuckoo filter, `false` if this is <i>definitely</i> not the case.
      *
      * @param {number} hash
      * @returns {boolean}
@@ -523,4 +523,4 @@ export class CuckooFilter {
                || (this.__victim_exists && this.__victim_tag === tag && (this.__victim_index === i1 || this.__victim_index === i2)) //check the victim
             ;
     }
-}
+}