@woosh/meep-engine 2.90.0 → 2.91.0

package/src/core/geom/2d/bvh/BVH2D.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=BVH2D.spec.d.ts.map

package/src/core/geom/2d/bvh/BVH2D.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BVH2D.spec.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/bvh/BVH2D.spec.js"],"names":[],"mappings":""}

package/src/core/geom/2d/bvh/BVH2D.spec.js

@@ -0,0 +1,358 @@
+import { randomFloatBetween } from "../../../math/random/randomFloatBetween.js";
+import { seededRandom } from "../../../math/random/seededRandom.js";
+import { BVH2D, NULL_NODE } from "./BVH2D.js";
+
+test("constructor doesn't throw", () => {
+    expect(() => new BVH2D()).not.toThrow();
+});
+
+test("initial root is NULL", () => {
+    const bvh = new BVH2D();
+
+    expect(bvh.root).toBe(NULL_NODE);
+});
+
+test("allocate a node", () => {
+    const bvh = new BVH2D();
+
+    const id = bvh.allocate_node();
+
+    expect(typeof id).toBe("number");
+    expect(Number.isInteger(id)).toBe(true);
+    expect(id).toBeGreaterThanOrEqual(0);
+});
+
+test("set/get aabb", () => {
+    const bvh = new BVH2D();
+
+    const node = bvh.allocate_node();
+
+    bvh.node_set_aabb(node, [1, -2, -5, 7]);
+
+    const result = [];
+
+    bvh.node_get_aabb(node, result);
+
+    expect(result).toEqual([
+        1, -2, -5, 7
+    ]);
+});
+
+test("insert one leaf", () => {
+    const bvh = new BVH2D();
+
+    const node = bvh.allocate_node();
+
+    bvh.insert_leaf(node);
+
+    expect(bvh.root).toBe(node);
+});
+
+test("node reuse after de-allocation", () => {
+
+    const bvh = new BVH2D();
+
+    const a = bvh.allocate_node();
+
+    bvh.release_node(a);
+
+    const b = bvh.allocate_node();
+
+    expect(b).toEqual(a);
+});
+
+test("insert two leaves", () => {
+
+    const bvh = new BVH2D();
+
+    const a = bvh.allocate_node();
+    bvh.insert_leaf(a);
+
+    const b = bvh.allocate_node();
+    bvh.insert_leaf(b);
+
+    const nodes = [];
+    bvh.collect_nodes_all(nodes, 0);
+
+    expect(nodes).toContain(a);
+    expect(nodes).toContain(b);
+});
+
+
+test("set/get user data", () => {
+
+    const bvh = new BVH2D();
+
+    const a = bvh.allocate_node();
+
+    bvh.node_set_user_data(a, 42);
+
+    expect(bvh.node_get_user_data(a)).toBe(42);
+});
+
+test("remove single leaf", () => {
+    const bvh = new BVH2D();
+
+    const a = bvh.allocate_node();
+    bvh.insert_leaf(a);
+
+    bvh.remove_leaf(a);
+
+    const nodes = [];
+    bvh.collect_nodes_all(nodes, 0);
+
+    expect(nodes).not.toContain(a);
+});
+
+test("add and remove 5 nodes", () => {
+
+    const bvh = new BVH2D();
+
+    const leaves = [];
+    const removed_leaves = [];
+
+    for (let i = 0; i < 5; i++) {
+        const a = bvh.allocate_node();
+        bvh.node_set_user_data(a, a);
+        bvh.insert_leaf(a);
+
+        leaves.push(a);
+    }
+
+    while (leaves.length > 0) {
+        const nodes = [];
+        bvh.collect_nodes_all(nodes, 0);
+
+        for (let j = 0; j < leaves.length; j++) {
+            const leaf = leaves[j];
+            expect(nodes).toContain(leaf);
+        }
+
+        const leaf = leaves.shift();
+
+        expect(bvh.node_get_user_data(leaf)).toBe(leaf);
+
+        bvh.remove_leaf(leaf);
+
+        removed_leaves.push(leaf);
+
+    }
+
+    const nodes = [];
+    bvh.collect_nodes_all(nodes, 0);
+    for (let i = 0; i < removed_leaves.length; i++) {
+        expect(nodes).not.toContain(removed_leaves[i]);
+    }
+
+});
+
+
+test("release_all from empty doesn't throw", () => {
+    const bvh = new BVH2D();
+
+    expect(() => bvh.release_all()).not.toThrow();
+});
+
+test("release_all with 1 leaf", () => {
+    const bvh = new BVH2D();
+
+    const a = bvh.allocate_node();
+
+    bvh.insert_leaf(a);
+
+    bvh.release_all();
+
+    expect(bvh.root).toBe(NULL_NODE);
+});
+
+test("capacity grows as necessary when allocating", () => {
+    const bvh = new BVH2D();
+
+    bvh.node_capacity = 1;
+
+    bvh.allocate_node();
+
+    bvh.allocate_node();
+
+    expect(bvh.node_capacity).toBeGreaterThanOrEqual(2);
+});
+
+test("trim sets capacity to exact allocated size", () => {
+    const bvh = new BVH2D();
+
+    bvh.node_capacity = 1;
+
+    bvh.allocate_node();
+
+    bvh.allocate_node();
+
+    bvh.trim();
+
+    expect(bvh.node_capacity).toBe(2);
+});
+
+
+test("node property setters/getters", () => {
+
+    const bvh = new BVH2D();
+
+    const node = bvh.allocate_node();
+
+    bvh.node_set_user_data(node, 3);
+
+    expect(bvh.node_get_user_data(node)).toBe(3);
+
+    bvh.node_set_child1(node, 7);
+    bvh.node_set_child2(node, 11);
+    bvh.node_set_parent(node, 13);
+    bvh.node_set_height(node, 17);
+
+    const expected_aabb = new Float32Array([1.1, 3.2, 11.4, 13.5]);
+    bvh.node_set_aabb(node, expected_aabb);
+
+    expect(bvh.node_get_child1(node)).toBe(7);
+    expect(bvh.node_get_child2(node)).toBe(11);
+    expect(bvh.node_get_parent(node)).toBe(13);
+    expect(bvh.node_get_height(node)).toBe(17);
+
+    const actual_aabb = [];
+    bvh.node_get_aabb(node, actual_aabb)
+
+    expect(actual_aabb).toEqual(Array.from(expected_aabb));
+});
+
+
+test("node_set_aabb_primitive", () => {
+    const bvh = new BVH2D();
+
+    const node = bvh.allocate_node();
+
+    bvh.node_set_aabb_primitive(node, -1, -3, 7, 11);
+
+    const aabb = [];
+
+    bvh.node_get_aabb(node, aabb);
+
+    expect(aabb).toEqual([-1, -3, 7, 11]);
+});
+
+test("swap two detached nodes", () => {
+    const bvh = new BVH2D();
+
+    const a = bvh.allocate_node();
+    const b = bvh.allocate_node();
+
+    bvh.node_set_user_data(a, 7);
+    bvh.node_set_user_data(b, 11);
+
+    bvh.swap_nodes(a, b);
+
+    expect(bvh.node_get_user_data(a)).toBe(11);
+    expect(bvh.node_get_user_data(b)).toBe(7);
+});
+
+test("setting capacity", () => {
+    const bvh = new BVH2D();
+
+    bvh.node_capacity = 3;
+
+    expect(bvh.node_capacity).toEqual(3);
+
+    bvh.node_capacity = 3;
+
+    expect(bvh.node_capacity).toEqual(3);
+
+    bvh.node_capacity = 0;
+
+    expect(bvh.node_capacity).toEqual(0);
+
+    bvh.allocate_node();
+
+    bvh.node_capacity = 3;
+
+    expect(bvh.node_capacity).toEqual(3);
+
+    bvh.node_capacity = 1;
+
+    expect(bvh.node_capacity).toEqual(1);
+
+    expect(() => bvh.node_capacity = 0).toThrow();
+});
+
+test("move leaf node", () => {
+    const bvh = new BVH2D();
+
+    const a = bvh.allocate_node();
+    const b = bvh.allocate_node();
+
+    bvh.node_set_aabb(a, [-1.1, -1.2, 2.1, 2.2]);
+    bvh.node_set_aabb(b, [3.1, 3.2, 5.1, 5.2]);
+
+    bvh.insert_leaf(a);
+    bvh.insert_leaf(b);
+
+    // convert to float32 and back to account for rounding errors when checking results
+    const a_new_bounds = Array.from(new Float32Array([
+        7.1, 7.2,
+        11.1, 11.2
+    ]));
+
+    bvh.node_move_aabb(a, a_new_bounds);
+
+    const actual_bounds = [];
+    bvh.node_get_aabb(a, actual_bounds);
+
+    expect(actual_bounds).toEqual(a_new_bounds);
+});
+
+test.skip("performance, insert 100k random nodes", () => {
+
+    const random = seededRandom(1);
+
+    const bvh = new BVH2D();
+
+    const min_bound = -1000;
+    const max_bound = 1000;
+
+    const OBJECT_COUNT = 100000;
+
+    const leaves = new Uint32Array(OBJECT_COUNT);
+    for (let i = 0; i < OBJECT_COUNT; i++) {
+        const node = bvh.allocate_node();
+
+        bvh.node_set_user_data(node, i);
+
+        const x = randomFloatBetween(random, min_bound, max_bound);
+        const y = randomFloatBetween(random, min_bound, max_bound);
+
+        const extents = randomFloatBetween(random, 1, 10);
+
+        const x0 = x - extents;
+        const y0 = y - extents;
+
+        const x1 = x + extents;
+        const y1 = y + extents;
+
+        // console.log([x0, y0, z0, x1, y1, z1].join(', '))
+
+        bvh.node_set_aabb_primitive(
+            node,
+            x0, y0,
+            x1, y1,
+        );
+    }
+
+    const t0 = performance.now();
+    for (let i = 0; i < OBJECT_COUNT; i++) {
+        const node = leaves[i];
+
+        bvh.insert_leaf(node);
+    }
+
+    const duration = performance.now() - t0;
+
+    const duration_seconds = duration * 1e-3;
+
+    console.log(`Duration ${duration_seconds}s, ${(OBJECT_COUNT / duration_seconds).toFixed(2)} records per second`);
+
+});

package/src/core/geom/2d/lt-grid/LooseTightGrid.js

@@ -1,8 +1,8 @@
 import { assert } from "../../../assert.js";
+import { de_interleave_2_bits } from "../../../binary/de_interleave_bits_by_2.js";
+import { split_by_2 } from "../../../binary/split_by_2.js";
 import { UINT32_MAX } from "../../../binary/UINT32_MAX.js";
 import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
-import { de_interleave_2_bits } from "../../3d/morton/de_interleave_bits_by_2.js";
-import { split_by_2 } from "../../3d/morton/split_by_2.js";
 import { BinaryElementPool } from "../../3d/topology/struct/binary/BinaryElementPool.js";
 
 const NULL_POINTER = UINT32_MAX;

package/src/core/geom/2d/quad-tree/QuadTreeNode.spec.js

@@ -183,7 +183,7 @@ test('test traverseRectangleIntersections', () => {
     expect(visitor0).toHaveBeenCalledWith(e, 0, 0, 3, 3);
 });
 
-test.skip("performance, insertion 1m random", () => {
+test("performance, insertion 1m random", () => {
     const tree = new QuadTreeNode(0, 0, 100, 100);
 
     const random = seededRandom(42);

package/src/core/geom/2d/r-tree/StaticR2Tree.d.ts

@@ -0,0 +1,79 @@
+/**
+ * NOTE: code is based on BinaryUint32BVH
+ * NOTE: this code is mostly untested
+ */
+export class StaticR2Tree {
+    /**
+     * @type {ArrayBuffer}
+     * @private
+     */
+    private __data_buffer;
+    /**
+     * @readonly
+     * @private
+     * @type {Uint32Array}
+     */
+    private readonly __data_uint32;
+    /**
+     *
+     * @type {number}
+     * @private
+     */
+    private __node_count_binary;
+    /**
+     *
+     * @type {number}
+     * @private
+     */
+    private __node_count_leaf;
+    /**
+     *
+     * @param {ArrayBuffer} buffer
+     */
+    setBuffer(buffer: ArrayBuffer): void;
+    __data_float32: Float32Array;
+    initialize_structure(): void;
+    /**
+     *
+     * @param {number} count
+     */
+    setLeafCount(count: number): void;
+    /**
+     *
+     * @param {number} index
+     * @param {number} payload
+     * @param {number} x0
+     * @param {number} y0
+     * @param {number} x1
+     * @param {number} y1
+     */
+    setLeafData(index: number, payload: number, x0: number, y0: number, x1: number, y1: number): void;
+    /**
+     *
+     * @returns {number}
+     */
+    getLeafBlockAddress(): number;
+    /**
+     *
+     * @param {number} leaf_index
+     * @returns {number}
+     */
+    readLeafPayload(leaf_index: number): number;
+    /**
+     * Sort leaf nodes according to their morton codes
+     * @param {number[]} bounds
+     */
+    sort_morton(bounds: number[]): void;
+    /**
+     *
+     * @param {number} i
+     * @param {number} j
+     * @private
+     */
+    private __swap_leaves;
+    /**
+     * Assemble leaf nodes into hierarchy, set binary node bounds iteratively bottom up
+     */
+    build(): void;
+}
+//# sourceMappingURL=StaticR2Tree.d.ts.map

package/src/core/geom/2d/r-tree/StaticR2Tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StaticR2Tree.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/r-tree/StaticR2Tree.js"],"names":[],"mappings":"AAoEA;;;GAGG;AACH;IAEI;;;OAGG;IACH,sBAAc;IAEd;;;;OAIG;IACH,+BAAc;IAEd;;;;OAIG;IACH,4BAAwB;IAExB;;;;OAIG;IACH,0BAAsB;IAOtB;;;OAGG;IACH,kBAFW,WAAW,QASrB;IAFG,6BAA0D;IAK9D,6BASC;IAED;;;OAGG;IACH,oBAFW,MAAM,QAchB;IAGD;;;;;;;;OAQG;IACH,mBAPW,MAAM,WACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAwBhB;IAED;;;OAGG;IACH,uBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,4BAHW,MAAM,GACJ,MAAM,CAQlB;IAGD;;;OAGG;IACH,oBAFW,MAAM,EAAE,QAgFlB;IAED;;;;;OAKG;IACH,sBAYC;IAED;;OAEG;IACH,cAsEC;CACJ"}