@woosh/meep-engine 2.110.14 → 2.110.15

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

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

package/src/core/bvh2/binary/2/BinaryUint32BVH.spec.js

@@ -1,136 +0,0 @@
-import { BinaryUint32BVH } from "./BinaryUint32BVH.js";
-
-test('constructor does not throw', () => {
-    new BinaryUint32BVH();
-});
-
-test('1 leaf build does not throw', () => {
-    const bvh = new BinaryUint32BVH();
-
-    bvh.setLeafCount(1);
-    bvh.initialize_structure();
-    bvh.build();
-});
-
-test('0 leaf tree must have a no binary nodes', () => {
-    const bvh = new BinaryUint32BVH();
-
-    bvh.setLeafCount(0);
-    bvh.initialize_structure();
-    bvh.build();
-
-    expect(bvh.binary_node_count).toBe(0);
-});
-
-test('1 leaf tree must have a single binary node', () => {
-    const bvh = new BinaryUint32BVH();
-
-    bvh.setLeafCount(1);
-    bvh.initialize_structure();
-    bvh.build();
-
-    expect(bvh.binary_node_count).toBe(1);
-});
-
-test('4 leaf tree must have a 3 binary nodes', () => {
-    const bvh = new BinaryUint32BVH();
-
-    bvh.setLeafCount(4);
-    bvh.initialize_structure();
-    bvh.build();
-
-    expect(bvh.binary_node_count).toBe(3);
-});
-
-test('read/write 1 leaf', () => {
-    const bvh = new BinaryUint32BVH();
-
-    bvh.setLeafCount(1);
-    bvh.initialize_structure();
-
-    bvh.setLeafData(0, 7, -3, -7, -11, 13, 17, 23);
-
-    expect(bvh.readLeafPayload(0)).toBe(7);
-
-    const bounds = [];
-    bvh.readBounds(bvh.getLeafBlockAddress(), bounds, 0);
-
-    expect(bounds[0]).toBeCloseTo(-3);
-    expect(bounds[1]).toBeCloseTo(-7);
-    expect(bounds[2]).toBeCloseTo(-11);
-    expect(bounds[3]).toBeCloseTo(13);
-    expect(bounds[4]).toBeCloseTo(17);
-    expect(bounds[5]).toBeCloseTo(23);
-});
-
-test("2 leaf node build", () => {
-    const bvh = new BinaryUint32BVH();
-
-    bvh.setLeafCount(2);
-    bvh.initialize_structure();
-
-    bvh.setLeafData(0, 3, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6);
-    bvh.setLeafData(1, 7, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6);
-
-    bvh.build();
-
-    const bounds = [];
-
-    bvh.readBounds(0, bounds, 0);
-
-    expect(bounds).toEqual(Array.from(new Float32Array([0.1, 0.2, 0.3, 1.4, 1.5, 1.6])));
-});
-
-test("1 leaf node build", () => {
-    const bvh = new BinaryUint32BVH();
-
-    bvh.setLeafCount(1);
-    bvh.initialize_structure();
-
-    bvh.setLeafData(0, 3, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6);
-
-    bvh.build();
-
-    const bounds = [];
-
-    bvh.readBounds(0, bounds, 0);
-
-    expect(bounds).toEqual(Array.from(new Float32Array([0.1, 0.2, 0.3, 0.4, 0.5, 0.6])));
-});
-
-test("3 leaf node build", () => {
-    const bvh = new BinaryUint32BVH();
-
-    bvh.setLeafCount(3);
-    bvh.initialize_structure();
-
-    bvh.setLeafData(0, 3, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6);
-    bvh.setLeafData(1, 7, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6);
-    bvh.setLeafData(2, 11, 2.1, 2.2, 2.3, 2.4, 2.5, 2.6);
-
-    bvh.build();
-
-    const bounds = [];
-
-    bvh.readBounds(0, bounds, 0);
-
-    expect(bounds).toEqual(Array.from(new Float32Array([0.1, 0.2, 0.3, 2.4, 2.5, 2.6])));
-});
-
-test('4 node sorted build', () => {
-    const bvh = new BinaryUint32BVH();
-
-    bvh.setLeafCount(4);
-    bvh.initialize_structure();
-
-    bvh.setLeafData(0, 3, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6);
-    bvh.setLeafData(1, 7, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6);
-    bvh.setLeafData(2, 11, 2.1, 2.2, 2.3, 2.4, 2.5, 2.6);
-    bvh.setLeafData(3, 13, 3.1, 3.2, 3.3, 3.4, 3.5, 3.6);
-
-    bvh.sort_morton([
-        0, 0, 0,
-        1, 1, 1
-    ]);
-    bvh.build();
-});

package/src/core/bvh2/bvh3/BVH.spec.js

@@ -1,361 +0,0 @@
-import { randomFloatBetween } from "../../math/random/randomFloatBetween.js";
-import { seededRandom } from "../../math/random/seededRandom.js";
-import { BVH, NULL_NODE } from "./BVH.js";
-
-test("constructor doesn't throw", () => {
-    expect(() => new BVH()).not.toThrow();
-});
-
-test("initial root is NULL", () => {
-    const bvh = new BVH();
-
-    expect(bvh.root).toBe(NULL_NODE);
-});
-
-test("allocate a node", () => {
-    const bvh = new BVH();
-
-    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 BVH();
-
-    const node = bvh.allocate_node();
-
-    bvh.node_set_aabb(node, [1, -2, 3, -5, 7, 11]);
-
-    const result = [];
-
-    bvh.node_get_aabb(node, result);
-
-    expect(result).toEqual([
-        1, -2, 3, -5, 7, 11
-    ]);
-});
-
-test("insert one leaf", () => {
-    const bvh = new BVH();
-
-    const node = bvh.allocate_node();
-
-    bvh.insert_leaf(node);
-
-    expect(bvh.root).toBe(node);
-});
-
-test("node reuse after de-allocation", () => {
-
-    const bvh = new BVH();
-
-    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 BVH();
-
-    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 BVH();
-
-    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 BVH();
-
-    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 BVH();
-
-    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 BVH();
-
-    expect(() => bvh.release_all()).not.toThrow();
-});
-
-test("release_all with 1 leaf", () => {
-    const bvh = new BVH();
-
-    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 BVH();
-
-    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 BVH();
-
-    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 BVH();
-
-    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, 7.3, 11.4, 13.5, 17.6]);
-    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 BVH();
-
-    const node = bvh.allocate_node();
-
-    bvh.node_set_aabb_primitive(node, -1, -3, -5, 7, 11, 13);
-
-    const aabb = [];
-
-    bvh.node_get_aabb(node, aabb);
-
-    expect(aabb).toEqual([-1, -3, -5, 7, 11, 13]);
-});
-
-test("swap two detached nodes", () => {
-    const bvh = new BVH();
-
-    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 BVH();
-
-    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 BVH();
-
-    const a = bvh.allocate_node();
-    const b = bvh.allocate_node();
-
-    bvh.node_set_aabb(a, [-1.1, -1.2, -1.3, 2.1, 2.2, 2.3]);
-    bvh.node_set_aabb(b, [3.1, 3.2, 3.2, 5.1, 5.2, 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, 7.3,
-        11.1, 11.2, 11.3
-    ]));
-
-    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 BVH();
-
-    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 z = randomFloatBetween(random, min_bound, max_bound);
-
-        const extents = randomFloatBetween(random, 1, 10);
-
-        const x0 = x - extents;
-        const y0 = y - extents;
-        const z0 = z - extents;
-
-        const x1 = x + extents;
-        const y1 = y + extents;
-        const z1 = z + extents;
-
-        // console.log([x0, y0, z0, x1, y1, z1].join(', '))
-
-        bvh.node_set_aabb_primitive(
-            node,
-            x0, y0, z0,
-            x1, y1, z1
-        );
-    }
-
-    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/bvh2/bvh3/BvhClient.spec.js

@@ -1,51 +0,0 @@
-import { BVH } from "./BVH.js";
-import { BvhClient } from "./BvhClient.js";
-import { bvh_query_leaves_generic } from "./query/bvh_query_leaves_generic.js";
-import { BVHQueryAny } from "./query/BVHQueryAny.js";
-
-test("connect/disconnect", () => {
-
-    const client = new BvhClient();
-
-    const bvh = new BVH();
-
-    client.bounds[0] = 2
-    client.bounds[1] = 3
-    client.bounds[2] = 5
-    client.bounds[3] = 7
-    client.bounds[4] = 11
-    client.bounds[5] = 13
-
-    expect(client.is_linked).toBe(false);
-
-    client.link(bvh, 17);
-
-    expect(client.is_linked).toBe(true);
-
-    const leaves = [];
-    bvh_query_leaves_generic(leaves, 0, bvh, bvh.root, BVHQueryAny.INSTANCE);
-
-    expect(leaves.length).toEqual(1);
-
-    const leaf = leaves[0];
-
-    expect(bvh.node_get_user_data(leaf)).toEqual(17);
-
-    const aabb = [];
-
-    bvh.node_get_aabb(leaf, aabb);
-
-    expect(aabb).toEqual(Array.from(client.bounds));
-
-    // disconnect
-    client.unlink();
-
-    expect(client.is_linked).toBe(false);
-
-    expect(bvh_query_leaves_generic(
-        leaves, 0,
-        bvh, bvh.root,
-        BVHQueryAny.INSTANCE
-    ))
-        .toBe(0);
-});

package/src/core/bvh2/bvh3/ebvh_build_for_geometry_morton.spec.js

@@ -1,60 +0,0 @@
-import { BVH, NULL_NODE } from "./BVH.js";
-import { ebvh_build_for_geometry_morton } from "./ebvh_build_for_geometry_morton.js";
-
-test("sanity check with 1 triangle", () => {
-
-    const bvh = new BVH();
-
-    ebvh_build_for_geometry_morton(bvh, [0, 1, 2], [
-        0, 1, 3,
-        13, 17, 19,
-        5, 7, 11
-    ]);
-
-    expect(bvh.root).not.toEqual(NULL_NODE);
-
-    const actual_bounds = [];
-    bvh.node_get_aabb(bvh.root, actual_bounds);
-
-    expect(actual_bounds).toEqual(
-        Array.from(new Float32Array([
-            0, 1, 3,
-            13, 17, 19
-        ]))
-    );
-
-    // check that first and only node has out triangle index stored
-    expect(bvh.node_is_leaf(bvh.root)).toEqual(true);
-    expect(bvh.node_get_user_data(bvh.root)).toEqual(0);
-});
-
-test("sanity check with 2 triangles", () => {
-    const bvh = new BVH();
-
-    ebvh_build_for_geometry_morton(
-        bvh,
-        [
-            0, 0, 0,
-            1, 1, 1
-        ],
-        [
-            0, 1, 3,
-            5, 7, 11
-        ]
-    );
-
-    expect(bvh.root).not.toEqual(NULL_NODE);
-
-    const actual_bounds = [];
-    bvh.node_get_aabb(bvh.root, actual_bounds);
-
-    expect(actual_bounds).toEqual(
-        Array.from(new Float32Array([
-            0, 1, 3,
-            5, 7, 11
-        ]))
-    );
-
-    // check that first and only node has out triangle index stored
-    expect(bvh.node_is_leaf(bvh.root)).toEqual(false);
-});

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

@@ -1,22 +0,0 @@
-import { BVH } from "../BVH.js";
-import { bvh_query_leaves_generic } from "./bvh_query_leaves_generic.js";
-import { BVHQueryAny } from "./BVHQueryAny.js";
-
-test("all-accepting query", () => {
-    const bvh = new BVH();
-
-    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.spec.js

@@ -1,64 +0,0 @@
-import { BVH } from "../BVH.js";
-import { bvh_query_leaves_ray } from "./bvh_query_leaves_ray.js";
-
-/**
- *
- * @param {number[]} leaves
- */
-function makeBVH(...leaves) {
-
-    const bvh = new BVH();
-
-    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);
-});