@woosh/meep-engine 2.48.22 → 2.49.0

package/editor/ecs/component/editors/three/BufferGeometryEditor.js

@@ -2,7 +2,7 @@ import { TypeEditor } from "../../TypeEditor.js";
 import { Sampler2D } from "../../../../../src/engine/graphics/texture/sampler/Sampler2D.js";
 import { renderObjectToSampler2D } from "../../../../../src/engine/graphics/util/renderObjectToSampler2D.js";
 import { Mesh, MeshPhongMaterial } from "three";
-import AABB2 from "../../../../../src/core/geom/AABB2.js";
+import AABB2 from "../../../../../src/core/geom/2d/aabb/AABB2.js";
 import { CanvasView } from "../../../../../src/view/elements/CanvasView.js";
 import sampler2D2Canvas from "../../../../../src/engine/graphics/texture/sampler/Sampler2D2Canvas.js";
 

package/editor/ecs/component/editors/three/MeshEditor.js

@@ -1,7 +1,7 @@
 import { TypeEditor } from "../../TypeEditor.js";
 import { Sampler2D } from "../../../../../src/engine/graphics/texture/sampler/Sampler2D.js";
 import { renderObjectToSampler2D } from "../../../../../src/engine/graphics/util/renderObjectToSampler2D.js";
-import AABB2 from "../../../../../src/core/geom/AABB2.js";
+import AABB2 from "../../../../../src/core/geom/2d/aabb/AABB2.js";
 import { CanvasView } from "../../../../../src/view/elements/CanvasView.js";
 import sampler2D2Canvas from "../../../../../src/engine/graphics/texture/sampler/Sampler2D2Canvas.js";
 import { threeUpdateTransform } from "../../../../../src/engine/graphics/util/threeUpdateTransform.js";

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/SelectionTool.js

@@ -5,7 +5,7 @@
 
 import Tool from './engine/Tool.js';
 import Vector2 from '../../src/core/geom/Vector2.js';
-import AABB2 from '../../src/core/geom/AABB2.js';
+import AABB2 from '../../src/core/geom/2d/aabb/AABB2.js';
 import { Camera } from '../../src/engine/graphics/ecs/camera/Camera.js';
 import View from '../../src/view/View.js';
 

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/editor/view/library/MeshLibraryView.js

@@ -4,7 +4,7 @@ import Vector2 from "../../../src/core/geom/Vector2.js";
 import domify from "../../../src/view/DOM.js";
 import LabelView from "../../../src/view/common/LabelView.js";
 import List from "../../../src/core/collection/list/List.js";
-import AABB2 from "../../../src/core/geom/AABB2.js";
+import AABB2 from "../../../src/core/geom/2d/aabb/AABB2.js";
 import { DragEvents } from "../../../src/engine/input/devices/events/DragEvents.js";
 import { MouseEvents } from "../../../src/engine/input/devices/events/MouseEvents.js";
 import { TouchEvents } from "../../../src/engine/input/devices/events/TouchEvents.js";

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.48.22",
+  "version": "2.49.0",
   "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/32BitEncoder.js

@@ -2,7 +2,7 @@ import { FunctionCompiler } from "../function/FunctionCompiler.js";
 import { assert } from "../assert.js";
 
 /**
- *
+ * Builds an encoder/decoder to simplify process of reading/writing various parts of a 32 bit field
  * @param {number[]} bitCounts
  * @returns {{encode: function(...number):number, decode: function(value:number, result:number[]):void}}
  */

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/LeafNode.js

@@ -2,8 +2,8 @@
  * Created by Alex on 17/11/2014.
  */
 import { Node } from "./Node.js";
-import { serializeAABB3 } from "./aabb3/serializeAABB3.js";
-import { deserializeAABB3 } from "./aabb3/deserializeAABB3.js";
+import { serializeAABB3 } from "../geom/3d/aabb/serializeAABB3.js";
+import { deserializeAABB3 } from "../geom/3d/aabb/deserializeAABB3.js";
 
 
 /**

package/src/core/bvh2/Node.d.ts

@@ -1,4 +1,4 @@
-import {AABB3} from "./aabb3/AABB3";
+import {AABB3} from "../geom/3d/aabb/AABB3";
 import {BinaryNode} from "./BinaryNode";
 
 export class Node<T> extends AABB3 {

package/src/core/bvh2/Node.js

@@ -2,7 +2,7 @@
  * Created by Alex on 17/11/2014.
  */
 import computeMortonCode from "../geom/3d/morton/Morton.js";
-import { AABB3 } from "./aabb3/AABB3.js";
+import { AABB3 } from "../geom/3d/aabb/AABB3.js";
 
 
 export class Node extends AABB3 {

package/src/core/bvh2/NodeValidator.js

@@ -4,7 +4,7 @@ import { buildShortStringPath } from "./Node.js";
 
 /**
  *
- * @param {NodeDescription} node
+ * @param {Node} node
  * @param {ViolationType} type
  * @param {String} message
  * @constructor

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/serialization/deserializeBinaryNode.js

@@ -1,6 +1,6 @@
 import { BinaryNode } from "../BinaryNode.js";
 import { deserializeLeafNode, LeafNode } from "../LeafNode.js";
-import { deserializeAABB3 } from "../aabb3/deserializeAABB3.js";
+import { deserializeAABB3 } from "../../geom/3d/aabb/deserializeAABB3.js";
 
 /**
  *

package/src/core/bvh2/serialization/deserializeBinaryNodeFromBinaryBuffer.js

@@ -1,7 +1,7 @@
 import { BinaryNode } from "../BinaryNode.js";
 import { LeafNode } from "../LeafNode.js";
-import { deserializeAABB3Encoded_v0 } from "../aabb3/deserializeAABB3Encoded_v0.js";
-import { deserializeAABB3 } from "../aabb3/deserializeAABB3.js";
+import { deserializeAABB3Encoded_v0 } from "../../geom/3d/aabb/deserializeAABB3Encoded_v0.js";
+import { deserializeAABB3 } from "../../geom/3d/aabb/deserializeAABB3.js";
 
 /**
  *

package/src/core/bvh2/serialization/serializeBinaryNode.js

@@ -1,5 +1,5 @@
 import { isLeaf, serializeLeafNode } from "../LeafNode.js";
-import { serializeAABB3 } from "../aabb3/serializeAABB3.js";
+import { serializeAABB3 } from "../../geom/3d/aabb/serializeAABB3.js";
 
 /**
  *

package/src/core/bvh2/serialization/serializeBinaryNodeToBinaryBuffer.js

@@ -1,5 +1,5 @@
-import { serializeAABB3 } from "../aabb3/serializeAABB3.js";
-import { serializeAABB3Encoded_v0 } from "../aabb3/serializeAABB3Encoded_v0.js";
+import { serializeAABB3 } from "../../geom/3d/aabb/serializeAABB3.js";
+import { serializeAABB3Encoded_v0 } from "../../geom/3d/aabb/serializeAABB3Encoded_v0.js";
 
 /**
  *

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);
+    });
+
+})