@woosh/meep-engine 2.110.14 → 2.110.15

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

@@ -1,29 +0,0 @@
-import { BVH } from "../BVH.js";
-import { bvh_query_user_data_generic } from "./bvh_query_user_data_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.node_set_user_data(leaf_a, 7);
-    bvh.node_set_user_data(leaf_b, 13);
-
-    bvh.insert_leaf(leaf_a);
-    bvh.insert_leaf(leaf_b);
-
-    const result = [];
-
-    const count = bvh_query_user_data_generic(
-        result, 1,
-        bvh, bvh.root,
-        BVHQueryAny.INSTANCE
-    );
-
-    expect(count).toBe(2);
-    expect(result).toContain(7);
-    expect(result).toContain(13);
-
-});

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

@@ -1,209 +0,0 @@
-import { aabb3_unsigned_distance_sqr_to_point } from "../../../geom/3d/aabb/aabb3_unsigned_distance_sqr_to_point.js";
-import { randomFloatBetween } from "../../../math/random/randomFloatBetween.js";
-import { seededRandom } from "../../../math/random/seededRandom.js";
-import { BVH } from "../BVH.js";
-import { bvh_query_user_data_nearest_to_point } from "./bvh_query_user_data_nearest_to_point.js";
-
-/**
- *
- * @param {number[]} boxes
- * @return {BVH}
- */
-function makeBvh(...boxes) {
-    const r = new BVH();
-
-    for (let i = 0; i < boxes.length; i++) {
-        const box = boxes[i];
-
-        const node = r.allocate_node();
-
-        r.node_set_aabb(node, box);
-        r.node_set_user_data(node, i);
-
-        r.insert_leaf(node);
-    }
-
-    return r;
-}
-
-test('no data, infinite distance', () => {
-    const bvh = makeBvh();
-
-    const result = bvh_query_user_data_nearest_to_point(bvh, 0, 0, 0, Infinity);
-
-    expect(result).toBe(-1);
-});
-
-test('single point, distance too short', () => {
-    const bvh = makeBvh([1, 0, 0, 1, 0, 0]);
-
-    const result = bvh_query_user_data_nearest_to_point(bvh, 0, 0, 0, 0.5);
-
-    expect(result).toBe(-1);
-});
-
-test('single point, distance sufficient', () => {
-    const bvh = makeBvh([1, 0, 0, 1, 0, 0]);
-
-    const result = bvh_query_user_data_nearest_to_point(bvh, 0, 0, 0, 1.5);
-
-    expect(result).not.toBe(-1);
-});
-
-test('two point, distance sufficient to one', () => {
-    const bvh = makeBvh(
-        [1, 0, 0, 1, 0, 0],
-        [2, 0, 0, 2, 0, 0],
-    );
-
-    const result = bvh_query_user_data_nearest_to_point(bvh, 0, 0, 0, 1.5);
-
-    expect(result).toBe(0);
-});
-
-test('two point, distance sufficient to both', () => {
-    const bvh = makeBvh(
-        [1, 0, 0, 1, 0, 0],
-        [2, 0, 0, 2, 0, 0],
-    );
-
-    const result = bvh_query_user_data_nearest_to_point(bvh, 0, 0, 0, 2.5);
-
-    expect(result).toBe(0);
-});
-
-
-test.skip("performance, 1M random boxes, 10k queries", () => {
-
-    const random = seededRandom(1);
-
-    const bvh = new BVH();
-
-    const min_bound = -1000;
-    const max_bound = 1000;
-
-    const OBJECT_COUNT = 1000000;
-
-    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, 50);
-
-        const x0 = x - extents;
-        const y0 = y - extents;
-        const z0 = z - extents;
-
-        const x1 = x + extents;
-        const y1 = y + extents;
-        const z1 = z + extents;
-
-        bvh.node_set_aabb_primitive(
-            node,
-            x0, y0, z0,
-            x1, y1, z1
-        );
-
-        bvh.insert_leaf(node);
-    }
-
-    const SAMPLE_POINT_COUNT = 10000;
-
-    const t0 = performance.now();
-
-    for (let i = 0; i < SAMPLE_POINT_COUNT; 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);
-
-        bvh_query_user_data_nearest_to_point(
-            bvh, x, y, z
-        );
-    }
-
-    const t1 = performance.now();
-
-    const duration = (t1 - t0);
-
-    console.log(`${duration / SAMPLE_POINT_COUNT}ms/query`);
-});
-
-test.skip('naive search, 1m random boxes, 10k queries', () => {
-
-    const random = seededRandom(1);
-
-    const OBJECT_COUNT = 1000000;
-
-    const boxes = new Float32Array(OBJECT_COUNT * 6);
-
-    const min_bound = -1000;
-    const max_bound = 1000;
-
-    const extents = 25;
-
-    for (let i = 0; i < OBJECT_COUNT; i++) {
-        const address = i * 6;
-
-        const x = randomFloatBetween(random, min_bound, max_bound);
-        const y = randomFloatBetween(random, min_bound, max_bound);
-        const z = randomFloatBetween(random, min_bound, max_bound);
-
-        boxes[address] = x - extents;
-        boxes[address + 1] = y - extents;
-        boxes[address + 2] = z - extents;
-
-        boxes[address + 3] = x + extents;
-        boxes[address + 4] = y + extents;
-        boxes[address + 5] = z + extents;
-
-    }
-
-    function naive_query(boxes, count, x, y, z) {
-        let best_distance_sqr = Infinity;
-        let best_index = 0;
-
-        const limit = count * 6;
-
-        for (let i = 0; i < limit; i += 6) {
-            const distance_sqr = aabb3_unsigned_distance_sqr_to_point(
-                boxes[i], boxes[i + 1], boxes[i + 2],
-                boxes[i + 3], boxes[i + 4], boxes[i + 5],
-
-                x, y, z
-            )
-
-            if (distance_sqr < best_distance_sqr) {
-                best_index = i;
-                best_distance_sqr = distance_sqr;
-            }
-        }
-
-        return best_index;
-    }
-
-    const SAMPLE_POINT_COUNT = 10000;
-
-    const t0 = performance.now();
-
-    for (let i = 0; i < SAMPLE_POINT_COUNT; 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);
-
-        naive_query(boxes, OBJECT_COUNT, x, y, z);
-    }
-
-    const t1 = performance.now();
-
-    const duration = (t1 - t0);
-
-    console.log(`${duration / SAMPLE_POINT_COUNT}ms/query`);
-
-});

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

@@ -1,41 +0,0 @@
-import { BVH } from "../BVH.js";
-import { compute_tight_near_far_clipping_planes } from "./compute_tight_near_far_clipping_planes.js";
-
-
-function orthographic_frustum(left, right, up, down, near, far) {
-    return new Float32Array([
-        1, 0, 0, right,
-        -1, 0, 0, -left,
-        0, 1, 0, down,
-        0, -1, 0, -up,
-        0, 0, 1, far,
-        0, 0, -1, -near
-    ]);
-}
-
-test('Empty does not throw', () => {
-    const bvh = new BVH();
-
-    const res = [];
-
-    const frustum = new Float32Array(24);
-
-    compute_tight_near_far_clipping_planes(res, 0, 0b000011, bvh, frustum);
-});
-
-test.skip('Axis-aligned, orthographic tight fit around a single small node', () => {
-    const frustum = orthographic_frustum(-1, 1, -1, 1, -1, 1);
-
-    const bvh = new BVH();
-
-    const leaf = bvh.allocate_node();
-    bvh.node_set_aabb(leaf, [-0.1, -0.1, -0.1, 0.1, 0.1, 0.1]);
-    bvh.insert_leaf(leaf);
-
-    const res = [];
-
-    compute_tight_near_far_clipping_planes(res, 0, 0b000011, bvh, frustum);
-
-    expect(res[4 * 4 + 3]).toBeCloseTo(0.1);
-    expect(res[4 * 5 + 3]).toBeCloseTo(0.1);
-});

package/src/core/cache/Cache.spec.js

@@ -1,277 +0,0 @@
-import { jest } from "@jest/globals";
-import { returnOne } from "../function/returnOne.js";
-import { Cache } from "./Cache.js";
-
-test("constructor doesn't throw", () => {
-    new Cache({});
-});
-
-test("elements beyond capacity are evicted", () => {
-
-    const cache = new Cache({ maxWeight: 3 });
-
-    cache.put(1, 1);
-    cache.put(2, 2);
-    cache.put(4, 4);
-    cache.put(5, 5);
-
-    expect(cache.size()).toBe(3);
-
-});
-
-test("trying to insert an element into the cache that's larger than the cache capacity should result in the item not being inserted", () => {
-    const cache = new Cache({
-        maxWeight: 1,
-        keyWeigher(key) {
-            return key;
-        }
-    });
-
-    cache.put(2, "hello");
-
-    expect(cache.contains(2)).toBe(false);
-});
-
-test("Recently accessed element should not be targeted for eviction where possible", () => {
-    const cache = new Cache();
-
-    cache.put(2, "hello");
-    cache.put(7, "world");
-
-    cache.get(2);
-
-    cache.evictOne();
-
-    expect(cache.has(2)).toBe(true);
-});
-
-test("removeListener is called when element is evicted", () => {
-
-    const removeListener = jest.fn();
-
-    const cache = new Cache({ maxWeight: 1 });
-    cache.onRemoved.add(removeListener);
-
-    cache.put(1, 7);
-
-    expect(removeListener).not.toHaveBeenCalled();
-
-    cache.put(2, 9);
-
-    expect(removeListener).toHaveBeenCalledTimes(1);
-    expect(removeListener).toHaveBeenCalledWith(1, 7);
-});
-
-test("new cache is empty", () => {
-    const cache = new Cache();
-
-    expect(cache.size()).toBe(0);
-});
-
-test("cache.drop() doesn't invoke removeListener", () => {
-    const removeListener = jest.fn();
-
-    const cache = new Cache();
-    cache.onRemoved.add(removeListener);
-
-    cache.put(1, 1);
-
-    cache.drop();
-
-    expect(removeListener).not.toHaveBeenCalled();
-});
-
-test("cache is emptied by cache.drop()", () => {
-    const cache = new Cache();
-
-    cache.put(1, 2);
-
-    cache.drop();
-
-    expect(cache.size()).toBe(0);
-});
-
-test("store and retrieve the same item", () => {
-
-    const cache = new Cache();
-
-    cache.put("a", "b");
-
-    expect(cache.get("a")).toBe("b");
-
-    cache.put("c", "d");
-
-    expect(cache.get("c")).toBe("d");
-});
-
-test("remove method", () => {
-    const cache = new Cache();
-
-    expect(cache.remove("a")).toBe(false);
-
-    cache.put("a", "b");
-
-    expect(cache.remove("a")).toBe(true);
-
-    expect(cache.size()).toBe(0);
-    expect(cache.get("a")).toBe(null);
-
-});
-
-test("replacing element with the same key", () => {
-    const cache = new Cache();
-
-    cache.put("a", "b");
-    cache.put("a", "c");
-
-    expect(cache.get("a")).toBe("c");
-});
-
-test("getOrCompute", () => {
-
-    const cache = new Cache();
-
-    const tokens = [1, 3, 5];
-
-    const compute = () => tokens.shift();
-
-    expect(cache.getOrCompute("x", compute)).toBe(1);
-
-    expect(cache.get("x")).toBe(1);
-
-    expect(cache.getOrCompute("x", compute)).toBe(1);
-
-    expect(cache.getOrCompute("y", compute)).toBe(3);
-
-    expect(cache.get("y")).toBe(3);
-
-    expect(cache.getOrCompute("y", compute)).toBe(3);
-
-})
-
-test("clear on empty does not throw", () => {
-
-    const cache = new Cache();
-
-    cache.clear();
-
-});
-
-test("clear with a single entry", () => {
-
-    const cache = new Cache();
-
-    cache.set("x", 1);
-
-    expect(cache.contains("x")).toBe(true);
-
-    cache.clear();
-
-    expect(cache.contains("x")).toBe(false);
-
-});
-
-test("calling 'evictOne' on empty cache should return false", () => {
-    const cache = new Cache();
-
-    expect(cache.evictOne()).toBe(false);
-});
-
-test("recomputeWeight", () => {
-    const cache = new Cache({
-        valueWeigher: () => 3,
-        keyWeigher: returnOne
-    });
-
-    cache.set(1, 1);
-
-    expect(cache.weight).toBe(4);
-
-    cache.recomputeWeight();
-
-    expect(cache.weight).toBe(4);
-});
-
-test("updateElementWeight", () => {
-    class Record {
-        weight = 0;
-
-        constructor(v) {
-            this.weight = v;
-        }
-    }
-
-    /**
-     *
-     * @type {Cache<string, Record>}
-     */
-    const cache = new Cache({
-        valueWeigher: (v) => v.weight,
-    });
-
-    const record_a = new Record(7);
-    const record_b = new Record(11);
-
-    cache.set("a", record_a);
-    cache.set("b", record_b);
-
-    expect(cache.weight).toBe(18);
-
-    record_a.weight = 3;
-
-    cache.updateElementWeight("a");
-
-    expect(cache.weight).toBe(14);
-
-    record_b.weight = 13;
-
-    cache.updateElementWeight("b");
-
-    expect(cache.weight).toBe(16);
-});
-
-test("silentRemove should not notify", () => {
-
-    const cache = new Cache();
-
-    cache.set("x", 1);
-
-    const mock = jest.fn();
-
-    cache.onRemoved.add(mock);
-
-    cache.silentRemove("x");
-
-    expect(cache.contains('x')).toBe(false);
-
-    expect(mock).not.toHaveBeenCalled();
-});
-
-test("setting maxWeight will drop data and update weight", () => {
-
-    const cache = new Cache();
-
-    cache.set("a", 1);
-    cache.set("b", 2);
-    cache.set("c", 3);
-
-    expect(cache.weight).toEqual(3);
-
-    cache.maxWeight = 1;
-
-    expect(cache.maxWeight).toEqual(1);
-    expect(cache.weight).toEqual(1);
-});
-
-test("setting maxWeight to 0 will empty out cache", () => {
-
-    const cache = new Cache();
-
-    cache.set("a", 1);
-    cache.set("b", 2);
-
-    cache.maxWeight = 0;
-
-    expect(cache.size()).toBe(0);
-
-});

package/src/core/cache/FrequencySketch.spec.js

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

package/src/core/cache/LoadingCache.spec.js

@@ -1,120 +0,0 @@
-import { LoadingCache } from "./LoadingCache.js";
-
-jest.useFakeTimers();
-
-test("successful load", () => {
-    const cache = new LoadingCache({
-        async load(key) {
-            return 17;
-        }
-    });
-
-    expect( cache.get(1)).resolves.toEqual(17);
-});
-
-test("when loader throws an exception, we should get a failed promise",  () => {
-    const cache = new LoadingCache({
-        load(key) {
-            throw "Designed Thrown Thing";
-        }
-    });
-
-    const promise = cache.get("a");
-
-    expect(promise).rejects.toEqual("Designed Thrown Thing");
-});
-
-test("record reuse", async () => {
-    const load = jest.fn(async () => 17);
-
-    const cache = new LoadingCache({
-        load
-    });
-
-    await expect(cache.get(1)).resolves.toEqual(17);
-    await expect(cache.get(1)).resolves.toEqual(17);
-
-    expect(load).toHaveBeenCalledTimes(1);
-});
-
-test("timeout reload reuse", async () => {
-
-    const values = [3, 5, 11];
-
-    const load = jest.fn(async () => values.pop());
-
-    const cache = new LoadingCache({
-        load,
-        timeToLive: 0.00000001
-    });
-
-    const request_1 = await cache.get(1);
-    expect(request_1).toEqual(11);
-
-    jest.advanceTimersByTime(1);
-
-    const request_2 = await cache.get(1);
-    expect(request_2).toEqual(5);
-
-    jest.advanceTimersByTime(1);
-
-    const request_3 = await cache.get(1);
-    expect(request_3).toEqual(3);
-});
-
-test("eviction", async () => {
-
-    /**
-     *
-     * @type {LoadingCache<number, number>}
-     */
-    const cache = new LoadingCache({
-        valueWeigher(num) {
-            return num;
-        },
-        load: async () => {
-            return 2;
-        },
-        maxWeight: 6,
-    });
-
-    await cache.get(1);
-    await cache.get(2);
-    await cache.get(3);
-
-    expect(cache.contains(1)).toBe(true);
-    expect(cache.contains(2)).toBe(true);
-    expect(cache.contains(3)).toBe(true);
-
-    await cache.get(4);
-
-    expect(cache.contains(1)).toBe(false);
-    expect(cache.contains(2)).toBe(true);
-    expect(cache.contains(3)).toBe(true);
-    expect(cache.contains(4)).toBe(true);
-
-});
-
-test("insert element directly", async () => {
-
-    const cache = new LoadingCache({
-        load: async () => 3
-    });
-
-    cache.put("x", 1);
-
-    expect(await cache.get("x")).toEqual(1);
-});
-
-test("clear", async () => {
-
-    const cache = new LoadingCache({
-        load: async () => 3
-    });
-
-    cache.put("x", 1);
-
-    cache.clear();
-
-    expect(await cache.get("x")).toEqual(3);
-});