@woosh/meep-engine 2.67.0 → 2.68.0

package/src/core/bvh2/BinaryNode.spec.js

@@ -1,309 +0,0 @@
-import { BinaryBuffer } from "../binary/BinaryBuffer.js";
-import { BinaryNode } from "./BinaryNode.js";
-import { isLeaf, LeafNode } from "./LeafNode.js";
-import { validateNode, validateTree } from "./NodeValidator.js";
-import { deserializeBinaryNode } from "./serialization/deserializeBinaryNode.js";
-import { deserializeBinaryNodeFromBinaryBuffer } from "./serialization/deserializeBinaryNodeFromBinaryBuffer.js";
-import { serializeBinaryNode } from "./serialization/serializeBinaryNode.js";
-import { serializeBinaryNodeToBinaryBuffer } from "./serialization/serializeBinaryNodeToBinaryBuffer.js";
-import {byteArrayToString} from "../binary/byteArrayToString.js";
-import {jsonToStringToByteArray} from "../binary/jsonToStringToByteArray.js";
-
-/**
- *
- * @param {AABB3} expected
- * @param {AABB3} actual
- * @param {number} [numDigits]
- */
-function compareBounds(expected, actual, numDigits = 2) {
-    expect(actual.x0).toBeCloseTo(expected.x0, numDigits);
-    expect(actual.y0).toBeCloseTo(expected.y0, numDigits);
-    expect(actual.z0).toBeCloseTo(expected.z0, numDigits);
-    expect(actual.x1).toBeCloseTo(expected.x1, numDigits);
-    expect(actual.y1).toBeCloseTo(expected.y1, numDigits);
-    expect(actual.z1).toBeCloseTo(expected.z1, numDigits);
-}
-
-/**
- *
- * @param {NodeDescription} expected
- * @param {NodeDescription} actual
- */
-function compareNodes(expected, actual) {
-    if (expected === undefined) {
-        expect(actual).toBeUndefined();
-    }
-    if (expected === null) {
-        expect(actual).toBeNull();
-    }
-
-    if (expected instanceof BinaryNode) {
-        expect(actual instanceof BinaryNode).toBeTruthy();
-        compareBounds(expected, actual);
-
-        compareNodes(expected.left, actual.left);
-        compareNodes(expected.right, actual.right);
-    } else if (expected instanceof LeafNode) {
-        expect(actual instanceof LeafNode).toBeTruthy();
-        compareBounds(expected, actual);
-        expect(actual.object).toEqual(expected.object);
-    }
-}
-
-expect.extend({
-    toBeValid(node) {
-        const violations = [];
-
-        function violationCallback(v) {
-            violations.push(v);
-        }
-
-        let pass = true;
-        if (isLeaf(node)) {
-            pass = pass && validateNode(node, violationCallback);
-        } else {
-            pass = pass && validateTree(node, violationCallback);
-        }
-
-        if (!pass) {
-            let message = violations.map((v) => v.toString()).join("\n");
-
-            if (message.trim().length === 0) {
-                message = `node is not valid`;
-            }
-
-            return {
-                message: function () {
-                    return message
-                },
-                pass: false
-            };
-        }
-
-        return {
-            pass: true
-        };
-    },
-    /**
-     *
-     * @param {BinaryNode} container
-     * @param node
-     */
-    toContainNode(container, node) {
-        let found = false;
-        let message;
-        container.traversePreOrderUsingStack(function (n) {
-            if (n === node) {
-                found = true;
-                //stop traversal
-                return false;
-            }
-        });
-
-        if (!found) {
-            message = `node is not contained within the tree`;
-        }
-
-        return {
-            message,
-            pass: found
-        };
-    }
-});
-
-test("constructor", () => {
-    const node = new BinaryNode();
-
-    expect(node.left).toBeNull();
-    expect(node.right).toBeNull();
-    expect(node.parentNode).toBeNull();
-});
-
-test("insert single leaf", () => {
-    const binaryNode = new BinaryNode();
-    binaryNode.setNegativelyInfiniteBounds();
-
-    const leafNode = new LeafNode(7, 1, 2, 3, 4, 5, 6);
-
-    binaryNode.insertNode(leafNode);
-
-    expect(binaryNode).toBeValid();
-    expect(leafNode).toBeValid();
-
-    expect(binaryNode).toContainNode(leafNode);
-    expect(leafNode.parentNode).toBe(binaryNode);
-});
-
-test("insert many leaves", () => {
-    const binaryNode = new BinaryNode();
-    binaryNode.setNegativelyInfiniteBounds();
-
-    const leaves = [];
-
-    for (let i = 0; i < 17; i++) {
-        const leafNode = new LeafNode(i, i, i, i, i + 1, i + 1, i + 1);
-        binaryNode.insertNode(leafNode);
-
-        leaves.push(leafNode);
-    }
-
-    expect(binaryNode).toBeValid();
-
-    for (let i = 0; i < leaves.length; i++) {
-        const leaf = leaves[i];
-
-        expect(leaf.computeRoot()).toBe(binaryNode);
-
-        expect(binaryNode).toContainNode(leaf);
-    }
-});
-
-test("disconnect single leaf", () => {
-    const binaryNode = new BinaryNode();
-    binaryNode.setNegativelyInfiniteBounds();
-
-    const leafNode = new LeafNode(7, 1, 2, 3, 4, 5, 6);
-
-    binaryNode.insertNode(leafNode);
-
-    expect(binaryNode).toContainNode(leafNode);
-
-    leafNode.disconnect();
-
-    expect(leafNode.parentNode).toBeNull();
-
-    expect(binaryNode).not.toContainNode(leafNode);
-
-    expect(binaryNode).toBeValid();
-});
-
-test("disconnect many leaves", () => {
-    const binaryNode = new BinaryNode();
-    binaryNode.setNegativelyInfiniteBounds();
-
-    const leaves = [];
-
-    for (let i = 0; i < 17; i++) {
-        const leafNode = new LeafNode(i, i, i, i, i + 1, i + 1, i + 1);
-        binaryNode.insertNode(leafNode);
-
-        leaves.push(leafNode);
-    }
-
-    expect(binaryNode).toBeValid();
-
-    for (let i = 0; i < leaves.length; i++) {
-        const leaf = leaves[i];
-        leaf.disconnect();
-
-        expect(leaf.parentNode).toBeNull();
-
-        expect(binaryNode).not.toContainNode(leaf);
-
-        expect(binaryNode).toBeValid();
-    }
-});
-
-test("serialization deserialization consistency", () => {
-    const expected = new BinaryNode();
-
-    expected.setNegativelyInfiniteBounds();
-
-    expected.insert(1, 2, 3, 4, 5, 6, "hello");
-    expected.insert(7, 8, 9, 10, 11, 12, "goodbye");
-    expected.insert(-6, -5, -4, -3, -2, -1, "world is cruel");
-
-    const buffer = new BinaryBuffer();
-
-    serializeBinaryNode(buffer, expected, function (buffer, value) {
-        const byteArray = new Uint8Array(jsonToStringToByteArray(value));
-        const numBytes = byteArray.length;
-        buffer.writeUint32(numBytes);
-        buffer.writeBytes(byteArray, 0, numBytes);
-    });
-
-    //reset position for reading
-    buffer.position = 0;
-
-    //
-    const actual = new BinaryNode();
-
-    deserializeBinaryNode(buffer, actual, function (buffer) {
-        const numBytes = buffer.readUint32();
-        const uint8Array = new Uint8Array(numBytes);
-        buffer.readBytes(uint8Array, 0, numBytes);
-
-        const text = byteArrayToString(uint8Array);
-        return JSON.parse(text);
-    });
-
-
-    compareNodes(expected, actual);
-});
-
-test("serialization deserialization consistency via to/fromBinaryBuffer", () => {
-    const expected = new BinaryNode();
-
-    expected.setNegativelyInfiniteBounds();
-
-    expected.insert(1, 2, 3, 4, 5, 6, "hello");
-    expected.insert(7, 8, 9, 10, 11, 12, "goodbye");
-    expected.insert(-6, -5, -4, -3, -2, -1, "world is cruel");
-
-    const buffer = new BinaryBuffer();
-
-    serializeBinaryNodeToBinaryBuffer(expected, buffer, function (buffer, value) {
-        const byteArray = new Uint8Array(jsonToStringToByteArray(value));
-        const numBytes = byteArray.length;
-        buffer.writeUint32(numBytes);
-        buffer.writeBytes(byteArray, 0, numBytes);
-    });
-
-    //reset position for reading
-    buffer.position = 0;
-
-    //
-    const actual = new BinaryNode();
-
-    deserializeBinaryNodeFromBinaryBuffer(actual, buffer, function (buffer) {
-        const numBytes = buffer.readUint32();
-        const uint8Array = new Uint8Array(numBytes);
-        buffer.readBytes(uint8Array, 0, numBytes);
-
-        const text = byteArrayToString(uint8Array);
-        return JSON.parse(text);
-    });
-
-
-    compareNodes(expected, actual);
-});
-
-test("setChildren", () => {
-    const root = new BinaryNode();
-
-    const a = new BinaryNode();
-    a.setBounds(0, 1, 2, 1, 1, 3);
-
-    const b = new BinaryNode();
-    b.setBounds(-1, -2, -3, 0, 2, 2);
-
-    root.setChildren(a, b);
-    root.refit();
-
-    expect(a.parentNode).toBe(root);
-    expect(b.parentNode).toBe(root);
-
-    expect(root.left).toBe(a);
-    expect(root.right).toBe(b);
-
-    //check refitting
-    expect(root.x0).toBe(-1);
-    expect(root.y0).toBe(-2);
-    expect(root.z0).toBe(-3);
-    expect(root.x1).toBe(1);
-    expect(root.y1).toBe(2);
-    expect(root.z1).toBe(3);
-
-    expect(root).toBeValid();
-});
-

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

@@ -1,7 +0,0 @@
-import {Node} from "./Node";
-
-export class LeafNode<T> extends Node<T> {
-    object: T
-
-    constructor(object: T, x0: number, y0: number, z0: number, x1: number, y1: number, z1: number)
-}

package/src/core/bvh2/LeafNode.js

@@ -1,147 +0,0 @@
-/**
- * Created by Alex on 17/11/2014.
- */
-import { deserializeAABB3 } from "../geom/3d/aabb/deserializeAABB3.js";
-import { serializeAABB3 } from "../geom/3d/aabb/serializeAABB3.js";
-import { Node } from "./Node.js";
-
-
-/**
- *
- * @param {Node|LeafNode} node
- * @returns {boolean}
- */
-function isLeaf(node) {
-    return node.isLeafNode;
-}
-
-/**
- * @deprecated use {@link BVH} and {@link BvhClient} respectively
- */
-export class LeafNode extends Node {
-    /**
-     *
-     * @param {*} object
-     * @param {number} x0
-     * @param {number} y0
-     * @param {number} z0
-     * @param {number} x1
-     * @param {number} y1
-     * @param {number} z1
-     * @constructor
-     */
-    constructor(object, x0, y0, z0, x1, y1, z1) {
-        super();
-
-        this.object = object;
-        this.parentNode = null;
-
-        this.x0 = x0;
-        this.y0 = y0;
-        this.z0 = z0;
-        this.x1 = x1;
-        this.y1 = y1;
-        this.z1 = z1;
-
-    }
-
-    /**
-     *
-     * @param {number} dx
-     * @param {number} dy
-     * @param {number} dz
-     */
-    move(dx, dy, dz) {
-        this.x0 += dx;
-        this.x1 += dx;
-        this.y0 += dy;
-        this.y1 += dy;
-        this.z0 += dz;
-        this.z1 += dz;
-        if (this.parentNode !== null) {
-            this.parentNode.bubbleRefit();
-        }
-    }
-
-    /**
-     *
-     * @param {number} x0
-     * @param {number} y0
-     * @param {number} z0
-     * @param {number} x1
-     * @param {number} y1
-     * @param {number} z1
-     */
-    resize(x0, y0, z0, x1, y1, z1) {
-        this.setBounds(x0, y0, z0, x1, y1, z1);
-
-        this.bubbleRefit();
-    }
-
-    bubbleRefit() {
-
-        if (this.parentNode !== null) {
-            this.parentNode.bubbleRefit();
-        }
-    }
-
-    /**
-     *
-     * @return {LeafNode}
-     */
-    clone() {
-        const clone = new LeafNode(this.object, this.x0, this.y0, this.z0, this.x1, this.y1, this.z1);
-
-        clone.parentNode = this.parentNode;
-
-        return clone;
-    }
-}
-
-/**
- *
- * @type {boolean}
- */
-LeafNode.prototype.isLeafNode = true;
-
-/**
- * Leaf node will have height 0, root node will have height equal to maximum depth of the tree
- * @type {number}
- */
-LeafNode.prototype.height = 0;
-
-/**
- * Useful shortcut, to avoid having to distinguish between leaf and intermediate nodes
- * @readonly
- * @deprecated
- * @type {number}
- */
-LeafNode.prototype.leafNodeCount = 1;
-
-/**
- *
- * @param {BinaryBuffer} buffer
- * @param {LeafNode} node
- * @param {function(buffer:BinaryBuffer, value:*):void} valueSerializer
- */
-function serializeLeafNode(buffer, node, valueSerializer) {
-    serializeAABB3(buffer, node);
-    valueSerializer(buffer, node.object);
-}
-
-/**
- *
- * @param {BinaryBuffer} buffer
- * @param {LeafNode} node
- * @param {function(buffer:BinaryBuffer):void} valueDeserializer
- */
-function deserializeLeafNode(buffer, node, valueDeserializer) {
-    deserializeAABB3(buffer, node);
-    node.object = valueDeserializer(buffer);
-}
-
-export {
-    isLeaf,
-    serializeLeafNode,
-    deserializeLeafNode
-};

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

@@ -1,9 +0,0 @@
-import {AABB3} from "../geom/3d/aabb/AABB3";
-import {BinaryNode} from "./BinaryNode";
-
-export class Node<T> extends AABB3 {
-    public parentNode: BinaryNode<T>
-
-
-    readonly leafNodeCount: number
-}

package/src/core/bvh2/Node.js

@@ -1,196 +0,0 @@
-/**
- * Created by Alex on 17/11/2014.
- */
-import computeMortonCode from "../geom/3d/morton/Morton.js";
-import { AABB3 } from "../geom/3d/aabb/AABB3.js";
-
-
-export class Node extends AABB3 {
-    constructor() {
-        super();
-
-        /**
-         *
-         * @type {BinaryNode|null}
-         */
-        this.parentNode = null;
-        this._mortonCode = void 0;
-    }
-
-    /**
-     * @return {boolean}
-     */
-    validateAncestorChain() {
-        //check containment
-        const parent = this.parentNode;
-        if (parent === null) {
-            //nothing to do
-            return true;
-        }
-
-        if (!parent.containsBox(this)) {
-            //bounds violated
-            return false;
-        }
-
-        if (parent.left === this || parent.right === this) {
-            //all is well
-        } else {
-            return false;
-        }
-
-        return true;
-    }
-
-    /**
-     *
-     * @returns {number}
-     */
-    computeDepth() {
-        let d = 0;
-        let node = this.parentNode;
-
-        while (node !== null) {
-            node = node.parentNode;
-
-            d++;
-        }
-
-        return d;
-    }
-
-    /**
-     *
-     * @returns {Node}
-     */
-    computeRoot() {
-        let p = this;
-
-        while (p.parentNode !== null) {
-            p = p.parentNode;
-        }
-
-        return p;
-    }
-
-    getMortonCode() {
-        if (this._mortonCode === void 0) {
-            const hx = (this.x1 + this.x0) / 2;
-            const hy = (this.y1 + this.y0) / 2;
-            const hz = (this.z1 + this.z0) / 2;
-            const mortonCode = computeMortonCode(hx, hy, hz);
-            this._mortonCode = mortonCode;
-            return mortonCode;
-        } else {
-            return this._mortonCode;
-        }
-    }
-
-    /**
-     * Expands current node and all ancestors until root to accommodate for given box, terminate if node is already
-     * large enough
-     * @param {AABB3} box
-     */
-    bubbleExpandToFit(box) {
-        let node = this;
-        while (node.expandToFit(box)) {
-            node = node.parentNode;
-            if (node === null) {
-                break;
-            }
-        }
-    }
-
-    /**
-     * @deprecated
-     */
-    remove() {
-        console.error("This method is deprecated, use 'disconnect' instead.");
-        this.disconnect();
-    }
-
-    /**
-     * Detaches this node from its parent
-     */
-    disconnect() {
-        const node = this.parentNode;
-
-        if (node === null) {
-            //no parent already
-            // console.warn(`Node has no parent, nothing to disconnect from`);
-            return;
-        }
-
-        if (this === node.left) {
-            node.left = null;
-            this.parentNode = null;
-        } else if (this === node.right) {
-            node.right = null;
-            this.parentNode = null;
-        } else {
-            throw new Error("impostor child");
-        }
-
-        node.updateLeafNodeCount();
-        node.updateHeight();
-    }
-
-    /**
-     * traverses all siblings up to the root
-     */
-    traverseSiblingsUp() {
-        throw new Error('Not Implemented');
-    }
-}
-
-function buildPathForNode(n) {
-
-    const chain = [];
-
-    let node = n;
-    while (node !== null) {
-
-        const parentNode = node.parentNode;
-
-        if (parentNode === null) {
-            break;
-        }
-
-        if (parentNode.left === node) {
-            chain.unshift('left');
-        } else {
-            chain.unshift('right');
-        }
-
-        node = parentNode;
-    }
-
-    return chain;
-}
-
-/**
- *
- * @param {string[]} path
- * @returns {string}
- */
-function strinfityPath(path) {
-    return '/' + path.join('/');
-}
-
-
-/**
- *
- * @param {Node} n
- * @param {int} len maximum number of path elements
- * @returns {string}
- */
-export function buildShortStringPath(n, len) {
-    const longPath = buildPathForNode(n);
-
-    if (longPath.length > len) {
-        return '...' + strinfityPath(longPath.splice(-len));
-    } else {
-        return strinfityPath(longPath);
-    }
-}
-