@woosh/meep-engine 2.110.13 → 2.110.15

package/src/engine/graphics/render/forward_plus/cluster/write_cluster_planes.spec.js

@@ -1,79 +0,0 @@
-import { write_cluster_planes } from "./write_cluster_planes.js";
-import { Plane } from "three";
-import Vector3 from "../../../../../core/geom/Vector3.js";
-
-test('split into 1', () => {
-    const result = [];
-
-    const a = new Plane();
-    const b = new Plane();
-
-    a.constant = 3;
-    b.constant = 7;
-
-    a.normal.set(1, 0, 0);
-    b.normal.set(-1, 0, 0);
-
-    write_cluster_planes(result, 0, 1, a, b);
-
-    expect(result).toEqual([
-        1, 0, 0, 3,
-        1, 0, 0, -7
-    ]);
-
-    //
-    a.normal.set(0, 1, 0);
-    b.normal.set(0, -1, 0);
-
-    write_cluster_planes(result, 0, 1, a, b);
-
-    expect(result).toEqual([
-        0, 1, 0, 3,
-        0, 1, 0, -7
-    ]);
-
-    //
-    a.normal.set(0, 0, 1);
-    b.normal.set(0, 0, -1);
-
-    write_cluster_planes(result, 0, 1, a, b);
-
-    expect(result).toEqual([
-        0, 0, 1, 3,
-        0, 0, 1, -7
-    ]);
-});
-
-test('split into 3 with 90 degrees between planes', () => {
-
-    const result = [];
-
-    const a = new Plane();
-    const b = new Plane();
-
-    a.constant = 3;
-    b.constant = 7;
-
-    a.normal.set(1, 0, 0);
-    b.normal.set(-1, 0, 0);
-
-    write_cluster_planes(result, 0, 3, a, b);
-
-    const v3 = new Vector3();
-
-    v3.readFromArray(result,0);
-
-    expect(v3.length()).toBe(1);
-
-    v3.readFromArray(result,4);
-
-    expect(v3.length()).toBe(1);
-
-    v3.readFromArray(result,8);
-
-    expect(v3.length()).toBe(1);
-
-    v3.readFromArray(result,12);
-
-    expect(v3.length()).toBe(1);
-})

package/src/engine/graphics/render/visibility/IncrementalDeltaSet.spec.js

@@ -1,102 +0,0 @@
-import { IncrementalDeltaSet } from "./IncrementalDeltaSet.js";
-
-import { number_compare_ascending } from "../../../../core/primitives/numbers/number_compare_ascending.js";
-
-test('set is sorted after insert, push 1,2', () => {
-    const set = new IncrementalDeltaSet(number_compare_ascending);
-
-    set.initializeUpdate();
-
-    set.push(1);
-    set.push(2)
-
-    set.finalizeUpdate();
-
-    expect(set.elements[0]).toBe(1);
-    expect(set.elements[1]).toBe(2);
-});
-
-test('set is sorted after insert, push 2,1', () => {
-    const set = new IncrementalDeltaSet(number_compare_ascending);
-
-    set.initializeUpdate();
-
-    set.push(2);
-    set.push(1);
-
-    set.finalizeUpdate();
-
-    expect(set.elements[0]).toBe(1);
-    expect(set.elements[1]).toBe(2);
-});
-
-test('set is sorted after insert, push 1,2,3', () => {
-    const set = new IncrementalDeltaSet(number_compare_ascending);
-
-    set.initializeUpdate();
-
-    set.push(1);
-    set.push(2);
-    set.push(3);
-
-    set.finalizeUpdate();
-
-    expect(set.elements[0]).toBe(1);
-    expect(set.elements[1]).toBe(2);
-    expect(set.elements[2]).toBe(3);
-});
-
-test('set is sorted after insert, push 3,2,1', () => {
-    const set = new IncrementalDeltaSet(number_compare_ascending);
-
-    set.initializeUpdate();
-
-    set.push(3);
-    set.push(2);
-    set.push(1);
-
-    set.finalizeUpdate();
-
-    expect(set.elements[0]).toBe(1);
-    expect(set.elements[1]).toBe(2);
-    expect(set.elements[2]).toBe(3);
-});
-
-
-test('add/remove callbacks', () => {
-    const set = new IncrementalDeltaSet(number_compare_ascending);
-
-    const add_listener = jest.fn();
-    const remove_listener = jest.fn();
-
-    set.onAdded.add(add_listener);
-    set.onRemoved.add(remove_listener);
-
-    set.initializeUpdate();
-
-    set.push(1);
-    set.push(2);
-    set.push(3);
-
-    set.finalizeUpdate();
-
-    expect(add_listener).toHaveBeenCalledWith(1);
-    expect(add_listener).toHaveBeenCalledWith(2);
-    expect(add_listener).toHaveBeenCalledWith(3);
-
-    expect(add_listener).toHaveBeenCalledTimes(3);
-
-    expect(remove_listener).not.toHaveBeenCalled();
-
-    set.initializeUpdate();
-
-    set.push(1);
-    set.push(3);
-
-    set.finalizeUpdate();
-
-    expect(add_listener).toHaveBeenCalledTimes(3);
-
-    expect(remove_listener).toHaveBeenCalledWith(2);
-    expect(remove_listener).toHaveBeenCalledTimes(1);
-});

package/src/engine/graphics/texture/atlas/CachingTextureAtlas.spec.js

@@ -1,78 +0,0 @@
-import { TextureAtlas } from "./TextureAtlas.js";
-import { CachingTextureAtlas } from "./CachingTextureAtlas.js";
-import { Sampler2D } from "../sampler/Sampler2D.js";
-
-test("constructor does not throw", () => {
-
-    const atlas = new TextureAtlas();
-
-    expect(() => new CachingTextureAtlas({ atlas })).not.toThrow();
-
-});
-
-test("add one", () => {
-
-    const atlas = new TextureAtlas();
-    const cached = new CachingTextureAtlas({ atlas });
-
-    const s = Sampler2D.uint8(4, 1, 1);
-
-    const patch = cached.add(s, 0);
-
-    expect(atlas.contains(patch)).toBe(true);
-
-});
-
-test("remove one", () => {
-
-    const atlas = new TextureAtlas();
-    const cached = new CachingTextureAtlas({ atlas });
-
-    const s = Sampler2D.uint8(4, 1, 1);
-
-    const patch = cached.add(s, 0);
-
-    expect(cached.remove(patch)).toBe(true);
-
-    // should stay cached
-    expect(atlas.contains(patch)).toBe(true);
-
-    // cache should tell us that patch is already removed
-    expect(cached.remove(patch)).toBe(false);
-
-});
-
-test("add patch that was already in the cache", () => {
-
-    const atlas = new TextureAtlas();
-    const cached = new CachingTextureAtlas({ atlas });
-
-    const s = Sampler2D.uint8(4, 1, 1);
-
-    const patch_a = cached.add(s, 0);
-
-    cached.remove(patch_a);
-
-    const patch_b = cached.add(s, 0);
-
-    expect(patch_a).toBe(patch_b);
-});
-
-test("eviction", () => {
-
-    const atlas = new TextureAtlas(1);
-    const cached = new CachingTextureAtlas({ atlas });
-
-    const sampler_a = Sampler2D.uint8(4, 1, 1);
-
-    const patch_a = cached.add(sampler_a, 0);
-
-    cached.remove(patch_a);
-    cached.update();
-
-    const sampler_b = Sampler2D.uint8(4, 1, 1);
-
-    const patch_b = cached.add(sampler_b, 0);
-
-    expect(atlas.contains(patch_a)).toBe(false);
-});

package/src/engine/graphics/texture/atlas/TextureAtlas.spec.js

@@ -1,319 +0,0 @@
-import { TextureAtlas } from "./TextureAtlas.js";
-import { Sampler2D } from "../sampler/Sampler2D.js";
-import { AtlasPatchFlag } from "./AtlasPatchFlag.js";
-import { AtlasPatch } from "./AtlasPatch.js";
-import { aabb2_overlap_exists } from "../../../../core/geom/2d/aabb/aabb2_overlap_exists.js";
-
-expect.extend({
-    toBeContainedInAtlas(patch, atlas) {
-        const patchX1 = patch.size.x + patch.padding + patch.position.x;
-        if (patchX1 > atlas.size.x) {
-            return {
-                message: `patch endX with padding(=${patchX1}) is greater than atlas width(=${atlas.size.x})`,
-                pass: false
-            };
-        }
-        const patchY1 = patch.size.y + patch.padding + patch.position.y;
-        if (patchY1 > atlas.size.y) {
-            return {
-                message: `patch endY with padding(=${patchY1}) is greater than atlas height(=${atlas.size.y})`,
-                pass: false
-            };
-        }
-
-        return {
-            pass: true,
-            message: `path is contained within the atlas`
-        };
-    }
-});
-
-test("constructor doesn't throw", () => {
-    new TextureAtlas();
-});
-
-
-test("packs 1 patch", () => {
-    const atlas = new TextureAtlas();
-    const patch = atlas.add(Sampler2D.uint8(4, 1, 1), 3);
-
-    atlas.update();
-
-    expect(patch).toBeContainedInAtlas(atlas);
-
-    //expect patch to be both painted and packed
-    expect(patch.getFlag(AtlasPatchFlag.Packed)).toBe(true);
-    expect(patch.getFlag(AtlasPatchFlag.Painted)).toBe(true);
-});
-
-test("snugly packs 16 patches 14x14 with 1px padding into 64x64 atlas", () => {
-
-    const atlas = new TextureAtlas();
-
-    for (let i = 0; i < 16; i++) {
-        atlas.add(Sampler2D.uint8(4, 14, 14), 1);
-    }
-
-    atlas.update();
-
-    expect(atlas.size.x).toBe(64);
-    expect(atlas.size.y).toBe(64);
-});
-
-test("build writes 2 patches into atlas", () => {
-    const atlas = new TextureAtlas();
-
-    const a = new Sampler2D([1, 2, 3, 4], 4, 1, 1);
-    const b = new Sampler2D([5, 6, 7, 8], 4, 1, 1);
-
-    const patchA = atlas.add(a, 1);
-    const patchB = atlas.add(b, 1);
-
-    atlas.update();
-
-    const sampler = atlas.sampler;
-
-    const result = [];
-    sampler.read(patchA.position.x, patchA.position.y, result);
-
-    expect(result).toEqual([1, 2, 3, 4]);
-
-    sampler.read(patchB.position.x, patchB.position.y, result);
-
-    expect(result).toEqual([5, 6, 7, 8]);
-});
-
-
-test("add method works correctly", () => {
-    const atlas = new TextureAtlas();
-
-    const s = Sampler2D.uint8(4, 1, 1);
-
-    const patch = atlas.add(s, 7);
-
-    //check flags
-    expect(patch.getFlag(AtlasPatchFlag.Packed)).toBe(false);
-    expect(patch.getFlag(AtlasPatchFlag.Painted)).toBe(false);
-
-    //check that sampler has been propagated
-    expect(patch.sampler).toBe(s);
-
-    //atlas should be marked as needing update
-    expect(atlas.needsUpdate()).toBe(true);
-
-    //atlas contains the patch
-    expect(atlas.contains(patch)).toBe(true);
-});
-
-test("contains method works correctly", () => {
-    const atlas = new TextureAtlas();
-
-    expect(atlas.contains(new AtlasPatch())).toBe(false);
-
-    const s = Sampler2D.uint8(4, 1, 1);
-
-    const patch = atlas.add(s, 7);
-
-    expect(atlas.contains(patch)).toBe(true);
-
-    //remove patch
-    atlas.remove(patch);
-
-    expect(atlas.contains(patch)).toBe(false);
-});
-
-test("remove method", () => {
-
-    const atlas = new TextureAtlas();
-
-    const s = Sampler2D.uint8(4, 1, 1);
-
-    s.writeChannel(0, 0, 0, 1);
-    s.writeChannel(0, 0, 1, 2);
-    s.writeChannel(0, 0, 2, 3);
-    s.writeChannel(0, 0, 3, 5);
-
-    const patch_a = atlas.add(s, 0);
-
-    expect(atlas.remove(patch_a)).toBe(true);
-
-    expect(atlas.remove(patch_a)).toBe(false);
-
-    // removed patch is erased
-    const patch_b = atlas.add(s, 0);
-
-    atlas.update();
-
-    atlas.remove(patch_b);
-
-    const p = patch_b.position;
-
-    expect(atlas.sampler.readChannel(p.x, p.y, 0)).toEqual(0);
-    expect(atlas.sampler.readChannel(p.x, p.y, 1)).toEqual(0);
-    expect(atlas.sampler.readChannel(p.x, p.y, 2)).toEqual(0);
-    expect(atlas.sampler.readChannel(p.x, p.y, 3)).toEqual(0);
-});
-
-test("reset", () => {
-    const atlas = new TextureAtlas();
-
-    expect(() => atlas.reset()).not.toThrow();
-
-    const s = Sampler2D.uint8(4, 1, 1);
-
-    const patch = atlas.add(s, 0);
-
-    atlas.reset();
-
-    expect(atlas.contains(patch)).toBe(false);
-});
-
-/**
- *
- * @param {AtlasPatch} patch
- * @param {TextureAtlas} atlas
- * @returns {boolean}
- */
-function isPatchDataPainted(patch, atlas) {
-    if (!atlas.contains(patch)) {
-        return false;
-    }
-
-    if (!patch.getFlag(AtlasPatchFlag.Painted)) {
-        return false;
-    }
-
-    const atlasSample = [];
-    const patchSample = [];
-
-    //check data
-    for (let i = 0; i < patch.size.x; i++) {
-        for (let j = 0; j < patch.size.y; j++) {
-
-            atlas.sampler.read(patch.position.x + i, patch.position.y + j, atlasSample);
-
-            patch.sampler.read(i, j, patchSample);
-
-            for (let k = 0; k < patchSample.length; k++) {
-                if (patchSample[k] !== atlasSample[k]) {
-                    return false;
-                }
-            }
-
-        }
-    }
-
-    return true;
-}
-
-/**
- *
- * @param {AtlasPatch[]} patches
- * @param {TextureAtlas} atlas
- * @returns {boolean}
- */
-function isPackingValid(patches, atlas) {
-    const patchCount = patches.length;
-
-    for (let i = 0; i < patchCount; i++) {
-        const patch0 = patches[i];
-
-        const x0 = patch0.position.x - patch0.padding;
-        const y0 = patch0.position.y - patch0.padding;
-
-        const x1 = x0 + patch0.size.x + patch0.padding * 2;
-        const y1 = y0 + patch0.size.y + patch0.padding * 2;
-
-        if (x0 < 0) {
-            return false;
-        }
-
-        if (y0 < 0) {
-            return false;
-        }
-
-        if (x1 > atlas.size.x) {
-            return false;
-        }
-
-        if (y1 > atlas.size.y) {
-            return false;
-        }
-
-        for (let j = i + 1; j < patchCount; j++) {
-            const patch1 = patches[j];
-
-
-            const _x0 = patch1.position.x - patch1.padding;
-            const _y0 = patch1.position.y - patch1.padding;
-
-            const _x1 = _x0 + patch1.size.x + patch1.padding * 2;
-            const _y1 = _y0 + patch1.size.y + patch1.padding * 2;
-
-            if (aabb2_overlap_exists(x0, y0, x1, y1, _x0, _y0, _x1, _y1)) {
-                return false;
-            }
-        }
-    }
-
-    return true;
-}
-
-test("add 7 patches an update each time", () => {
-    const atlas = new TextureAtlas(0);
-
-    const patches = [];
-
-    for (let i = 0; i < 7; i++) {
-
-        const s = Sampler2D.uint8(4, 1, 1);
-
-        s.set(0, 0, [i, i, i, i]);
-
-        const patch = atlas.add(s, 1);
-
-        //check that patch is registered as contained
-        expect(atlas.contains(patch));
-
-        //do an update
-        atlas.update();
-
-        //verify that patch data is painted propertly
-        expect(isPatchDataPainted(patch, atlas)).toBe(true);
-
-        //check that all the other patches are still written properly
-        for (let j = 0; j < patches.length; j++) {
-            const patch1 = patches[j];
-
-            expect(isPatchDataPainted(patch1, atlas)).toBe(true);
-        }
-
-        patches.push(patch);
-
-        //check that there are no overlaps of patches
-        expect(isPackingValid(patches, atlas)).toBe(true);
-    }
-
-});
-
-test("modified sampler get repainted during 'paint'", () => {
-    const atlas = new TextureAtlas();
-
-    const sampler = Sampler2D.uint8(4, 1, 1);
-
-    sampler.data.fill(7);
-
-    const patch = atlas.add(sampler);
-
-    atlas.update();
-
-    // modify sampler
-    sampler.data.fill(3);
-    sampler.version++;
-
-    atlas.paint(); //repaint
-
-    const v0 = atlas.sampler.readChannel(patch.position.x, patch.position.y, 0)
-
-    expect(v0).toBe(3);
-});

package/src/engine/graphics/texture/sampler/HarmonicDiffusionGrid.spec.js

@@ -1,99 +0,0 @@
-import { randomIntegerBetween } from "../../../../core/math/random/randomIntegerBetween.js";
-import { seededRandom } from "../../../../core/math/random/seededRandom.js";
-import { HarmonicDiffusionGrid } from "./HarmonicDiffusionGrid.js";
-
-test("constructor doesn't throw", () => {
-    new HarmonicDiffusionGrid([], 0, 0);
-});
-
-test("step 1x1 unassigned", () => {
-    const grid = new HarmonicDiffusionGrid([7], 1, 1);
-
-    grid.step();
-
-    expect(grid.data.length).toEqual(1);
-});
-
-test("step 1x1 assigned", () => {
-    const grid = new HarmonicDiffusionGrid([7], 1, 1);
-
-    grid.assign(0, 0, 13);
-
-    grid.step();
-
-    expect(grid.data).toEqual([13]);
-});
-
-test("step 3x3 edges assigned", () => {
-    const grid = new HarmonicDiffusionGrid(new Array(9).fill(0), 3, 3);
-
-    grid.assign(0, 0, 1);
-    grid.assign(1, 0, 2);
-    grid.assign(2, 0, 3);
-
-    grid.assign(0, 1, 4);
-    grid.assign(2, 1, 6);
-
-    grid.assign(0, 2, 7);
-    grid.assign(1, 2, 8);
-    grid.assign(2, 2, 9);
-
-    grid.step();
-
-    expect(grid.data).toEqual([
-        1, 2, 3,
-        4, 5, 6,
-        7, 8, 9
-    ]);
-});
-
-test("20 step 3x1, corner assigned", () => {
-    const grid = new HarmonicDiffusionGrid(new Array(3).fill(0), 3, 1);
-
-    grid.assign(0, 0, 5);
-
-    for (let i = 0; i < 20; i++) {
-        grid.step();
-    }
-
-    expect(grid.data[0]).toBe(5);
-    expect(grid.data[1]).toBeCloseTo(5);
-    expect(grid.data[2]).toBeCloseTo(5);
-});
-
-test("20 step 4x1, corners assigned", () => {
-    const grid = new HarmonicDiffusionGrid(new Array(4).fill(0), 4, 1);
-
-    grid.assign(0, 0, 5);
-    grid.assign(3, 0, -7);
-
-    for (let i = 0; i < 20; i++) {
-        grid.step();
-    }
-
-    expect(grid.data[0]).toBe(5);
-    expect(grid.data[1]).toBeCloseTo(1);
-    expect(grid.data[2]).toBeCloseTo(-3);
-    expect(grid.data[3]).toBe(-7);
-});
-
-test.skip("performance 512x512", () => {
-    const w = 139;
-    const h = 139;
-
-    const grid = new HarmonicDiffusionGrid(new Float32Array(w * h).fill(0), w, h);
-
-    const rng = seededRandom(42);
-    let i;
-    for (i = 0; i < 100; i++) {
-        const x = randomIntegerBetween(rng, 0, w - 1);
-        const y = randomIntegerBetween(rng, 0, h - 1);
-        grid.assign(x, y, rng());
-    }
-
-    console.time('t');
-    for (i = 0; i < 500; i++) {
-        grid.step();
-    }
-    console.timeEnd('t');
-});