@woosh/meep-engine 2.67.0 → 2.68.0

package/src/core/bvh2/NodeValidator.js

@@ -1,197 +0,0 @@
-import { BinaryNode } from "./BinaryNode.js";
-import { isLeaf } from "./LeafNode.js";
-import { buildShortStringPath } from "./Node.js";
-
-/**
- *
- * @param {Node} node
- * @param {ViolationType} type
- * @param {String} message
- * @constructor
- */
-function Violation(node, type, message) {
-    this.node = node;
-    this.type = type;
-    this.message = message;
-}
-
-
-Violation.prototype.toString = function () {
-    return `Path: ${buildShortStringPath(this.node, 5)}, Type: ${this.type}, Message: ${this.message}`;
-};
-
-/**
- *
- * @enum {string}
- */
-const ViolationType = {
-    IllegalChildValue: "illegal child value",
-    IllegalParentValue: "illegal parent value",
-    Containment: "containment",
-    Bounds: "bounds"
-};
-
-
-/**
- *
- * @param {BinaryNode} node
- * @param {function(Violation)} violationCallback
- * @returns {boolean}
- */
-function validateTree(node, violationCallback) {
-    const visited = new Set();
-    let violatingNodes = 0;
-    node.traversePreOrder(function (n) {
-        if (visited.has(n)) {
-            violatingNodes++;
-            addReason(node, ViolationType.Containment, `node is found in multiple locations in the tree`, violationCallback);
-        } else {
-            visited.add(n);
-        }
-
-        let isValid = validateNode(n, violationCallback);
-
-        if (!isValid) {
-            violatingNodes++;
-        }
-    });
-    return violatingNodes === 0;
-}
-
-function addReason(node, type, message, reasonCallback, reasonCallbackThisArg) {
-    if (typeof reasonCallback === "function") {
-        const violation = new Violation(node, type, message);
-        reasonCallback.call(reasonCallbackThisArg, violation);
-    }
-}
-
-/**
- *
- * @param {NodeDescription} node
- * @param {function(Violation)} violationCallback
- * @param reasonCallbackThisArg
- * @returns {boolean}
- */
-function validateNode(node, violationCallback, reasonCallbackThisArg) {
-    let result = true;
-
-    /**
-     *
-     * @param {*} value
-     * @param {string} name
-     * @returns {boolean}
-     */
-    function validateCoordinate(value, name) {
-        let result = true;
-        if (typeof value !== "number") {
-            addReason(node, ViolationType.Bounds, `${name} must be a number, but instead was ${typeof value}`, violationCallback, reasonCallbackThisArg);
-            result = false;
-        } else if (Number.isNaN(value)) {
-            addReason(node, ViolationType.Bounds, `${name} is NaN`, violationCallback, reasonCallbackThisArg);
-            result = false;
-        }
-        return result;
-    }
-
-    function validateAxis(name) {
-        const v0Name = name + "0";
-        const v1Name = name + "1";
-
-        const v0 = node[v0Name];
-        const v1 = node[v1Name];
-
-        const valid0 = validateCoordinate(v0, v0Name);
-        const valid1 = validateCoordinate(v1, v1Name);
-
-        if (!valid0 || !valid1) {
-            result = false;
-        } else if (v0 > v1) {
-            addReason(node, ViolationType.Bounds, `${v0Name}(=${v0}) > ${v1Name}(=${v1}), negative size`, violationCallback, reasonCallbackThisArg);
-            result = false;
-        }
-    }
-
-    //check bounds
-    validateAxis("x");
-    validateAxis("y");
-    validateAxis("z");
-
-    if (!isLeaf(node)) {
-        const binaryNodeConstraintsValid = validateBinaryNode(node, violationCallback, reasonCallbackThisArg);
-        if (!binaryNodeConstraintsValid) {
-            result = false;
-        }
-    }
-
-    return result;
-}
-
-/**
- *
- * @param {BinaryNode} node
- * @param {function(Violation)} [reasonCallback]
- * @param {*} [reasonCallbackThisArg]
- * @returns {boolean}
- */
-function validateBinaryNode(node, reasonCallback, reasonCallbackThisArg) {
-
-    function validateChild(child, name) {
-        if (child === null) {
-            return true;
-        }
-
-        if (child === undefined) {
-            addReason(node, ViolationType.IllegalChildValue, name + " child is 'undefined', this is an illegal value.", reasonCallback, reasonCallbackThisArg);
-            return false;
-        }
-
-        if (child.parentNode !== node) {
-            addReason(node, ViolationType.IllegalParentValue, name + " child is parented to different node than this one.", reasonCallback, reasonCallbackThisArg);
-            return false;
-        }
-
-        if (!node.containsBox(child)) {
-            addReason(node, ViolationType.Containment, name + " child violates parent's bounds", reasonCallback, reasonCallbackThisArg);
-            return false;
-        }
-
-        return true;
-    }
-
-    let result = true;
-
-    result = result && validateChild(node.left, "left");
-    result = result && validateChild(node.right, "right");
-
-    //left and right node must be different nodes
-    if (node.left !== null && node.left === node.right) {
-        addReason(node, ViolationType.IllegalChildValue, "left and right child are the same non-null node", reasonCallback, reasonCallbackThisArg);
-        result = false;
-    }
-
-    return result;
-}
-
-function validateContainment(node, violation) {
-    if (node.left !== null) {
-        if (!node.containsBox(node.left)) {
-            violation(node.left)
-        } else if (node.left instanceof BinaryNode) {
-            validateContainment(node.left, violation);
-        }
-
-    }
-    if (node.right !== null) {
-        if (!node.containsBox(node.right)) {
-            violation(node.right)
-        } else if (node.right instanceof BinaryNode) {
-            validateContainment(node.right, violation);
-        }
-    }
-}
-
-export {
-    ViolationType,
-    validateNode,
-    validateTree
-};

package/src/core/bvh2/StacklessTraverser.js

@@ -1,154 +0,0 @@
-import { isLeaf } from "./LeafNode.js";
-
-const StateFromParent = 0;
-const StateFromSibling = 1;
-const StateFromChild = 2;
-
-function getLeft(node) {
-    return node.left;
-}
-
-function parent(node) {
-    return node.parentNode;
-}
-
-function sibling(node) {
-    const parentNode = node.parentNode;
-    return parentNode.right;
-}
-
-
-/**
- * Implementation based on code listing from paper:
- * "Efficient Stack-less BVH Traversal for Ray Tracing" 2011 Michal Hapala et.al
- * http://www.sci.utah.edu/~wald/Publications/2011/StackFree/sccg2011.pdf
- *
- * NOTE: Based on a few quick benchmarks this algorithm is slower than using stack
- * NOTE: this algorithm could be useful for incremental traversal as it retains state
- */
-function StacklessTraverser() {
-    this.state = 0;
-    /**
-     *
-     * @type {BinaryNode|null}
-     */
-    this.current = null;
-}
-
-/**
- *
- * @param {BinaryNode} node
- */
-StacklessTraverser.prototype.init = function (node) {
-    this.root = node;
-    this.state = StateFromParent;
-    this.current = node;
-};
-
-/**
- *
- * Advanced traverser. Visitor will be invoked only on those advancements that produce a unique visit
- * @param {function(node:NodeDescription):boolean} visitor terminate branch and do no traverse descendants when visitor returns false
- * @param {*} [thisArg]
- * @returns {boolean}
- */
-StacklessTraverser.prototype.advance = function (visitor, thisArg) {
-    let n;
-
-    let state = this.state, current = this.current;
-
-    switch (state) {
-        case StateFromChild:
-            //traversal up
-            if (current === this.root) {
-                //finished
-                return false;
-            }
-            n = sibling(current);
-            if (current === n || n == null) {
-                //ascend
-                current = parent(current);
-                state = StateFromChild;
-            } else {
-                //move right
-                current = n;
-                state = StateFromSibling;
-            }
-            break;
-        case StateFromSibling:
-            if (visitor.call(thisArg, current) === false || isLeaf(current)) {
-                current = parent(current);
-                state = StateFromChild;
-            } else {
-                n = getLeft(current);
-                if (n === null) {
-                    //ascent
-                    current = parent(current);
-                    state = StateFromChild;
-                } else {
-                    //descend
-                    current = n;
-                    state = StateFromParent;
-                }
-            }
-            break;
-        case StateFromParent:
-            if (visitor.call(thisArg, current) === false || isLeaf(current)) {
-                n = sibling(current);
-                if (n == null) {
-                    //ascend
-                    current = parent(current);
-                    state = StateFromChild;
-                } else {
-                    //more right
-                    current = n;
-                    state = StateFromSibling;
-                }
-            } else {
-                n = getLeft(current);
-                if (n === null) {
-                    if (current.parentNode === null) {
-                        //already at root
-                        n = current.right;
-                        if (n === null) {
-                            //put traverser into terminal state
-                            current = this.root;
-                            state = StateFromChild;
-                        } else {
-                            current = n;
-                            state = StateFromSibling;
-                        }
-                    } else {
-
-                        n = sibling(current);
-                        if (n === null) {
-                            //ascent
-                            current = parent(current);
-                            state = StateFromChild;
-
-                        } else {
-                            current = n;
-                            state = StateFromSibling;
-                        }
-                    }
-                } else {
-                    //descend
-                    current = n;
-                    state = StateFromParent;
-                }
-            }
-            break;
-    }
-
-    this.current = current;
-    this.state = state;
-
-    return true;
-};
-
-export {
-    StacklessTraverser,
-    StateFromParent,
-    StateFromSibling,
-    StateFromChild
-};

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

@@ -1,109 +0,0 @@
-import { jest } from "@jest/globals";
-import { BinaryNode } from "./BinaryNode.js";
-import { StacklessTraverser } from "./StacklessTraverser.js";
-
-test("empty node traversal", () => {
-    const node = new BinaryNode();
-
-    const traverser = new StacklessTraverser();
-
-    traverser.init(node);
-
-    const visitor = jest.fn();
-
-    expect(traverser.advance(visitor)).toBe(true);
-
-    expect(visitor).toHaveBeenCalledTimes(1);
-    expect(visitor).toHaveBeenCalledWith(node);
-
-    expect(traverser.advance(visitor)).toBe(false);
-
-    expect(visitor).toHaveBeenCalledTimes(1);
-});
-
-test("only left child", () => {
-    const node = new BinaryNode();
-    node.left = new BinaryNode();
-    node.left.parentNode = node;
-
-    const traverser = new StacklessTraverser();
-
-    traverser.init(node);
-
-    const visitor = jest.fn();
-
-    expect(traverser.advance(visitor)).toBe(true);
-
-    expect(visitor).toHaveBeenCalledTimes(1);
-    expect(visitor).toHaveBeenCalledWith(node);
-
-    expect(traverser.advance(visitor)).toBe(true);
-
-    expect(visitor).toHaveBeenCalledTimes(2);
-    expect(visitor).toHaveBeenLastCalledWith(node.left);
-
-    expect(traverser.advance(visitor)).toBe(false);
-
-    expect(visitor).toHaveBeenCalledTimes(2);
-});
-
-test("only right child", () => {
-    const node = new BinaryNode();
-    node.right = new BinaryNode();
-    node.right.parentNode = node;
-
-    const traverser = new StacklessTraverser();
-
-    traverser.init(node);
-
-    const visitor = jest.fn();
-
-    expect(traverser.advance(visitor)).toBe(true);
-
-    expect(visitor).toHaveBeenCalledTimes(1);
-    expect(visitor).toHaveBeenCalledWith(node);
-
-    expect(traverser.advance(visitor)).toBe(true);
-
-    expect(visitor).toHaveBeenCalledTimes(2);
-    expect(visitor).toHaveBeenLastCalledWith(node.right);
-
-    expect(traverser.advance(visitor)).toBe(false);
-
-    expect(visitor).toHaveBeenCalledTimes(2);
-});
-
-test("node with left and right child", () => {
-    const node = new BinaryNode();
-
-    node.right = new BinaryNode();
-    node.right.parentNode = node;
-
-    node.left = new BinaryNode();
-    node.left.parentNode = node;
-
-    const traverser = new StacklessTraverser();
-
-    traverser.init(node);
-
-    const visitor = jest.fn();
-
-    expect(traverser.advance(visitor)).toBe(true);
-
-    expect(visitor).toHaveBeenCalledTimes(1);
-    expect(visitor).toHaveBeenCalledWith(node);
-
-    expect(traverser.advance(visitor)).toBe(true);
-
-    expect(visitor).toHaveBeenCalledTimes(2);
-    expect(visitor).toHaveBeenLastCalledWith(node.left);
-
-    expect(traverser.advance(visitor)).toBe(true);
-
-    expect(visitor).toHaveBeenCalledTimes(3);
-    expect(visitor).toHaveBeenLastCalledWith(node.right);
-
-    expect(traverser.advance(visitor)).toBe(false);
-
-    expect(visitor).toHaveBeenCalledTimes(3);
-});

package/src/core/bvh2/serialization/deserializeBinaryNode.js

@@ -1,40 +0,0 @@
-import { BinaryNode } from "../BinaryNode.js";
-import { deserializeLeafNode, LeafNode } from "../LeafNode.js";
-import { deserializeAABB3 } from "../../geom/3d/aabb/deserializeAABB3.js";
-
-/**
- *
- * @param {BinaryBuffer} buffer
- * @param {BinaryNode} node
- * @param {function(buffer:BinaryBuffer):void} leafValueDeserializer
- */
-function deserializeBinaryNode(buffer, node, leafValueDeserializer) {
-    deserializeAABB3(buffer, node);
-
-    function deserializeChild() {
-        const nodeType = buffer.readUint8();
-        if (nodeType === 0) {
-            return null;
-        } else if (nodeType === 1) {
-            const leafNode = new LeafNode();
-            deserializeLeafNode(buffer, leafNode, leafValueDeserializer);
-            leafNode.parentNode = node;
-            return leafNode;
-        } else if (nodeType === 2) {
-            const binaryNode = new BinaryNode();
-            deserializeBinaryNode(buffer, binaryNode, leafValueDeserializer);
-            binaryNode.parentNode = node;
-            return binaryNode;
-        }
-    }
-
-    const leftNode = deserializeChild();
-    const rightNode = deserializeChild();
-
-    node.left = leftNode;
-    node.right = rightNode;
-
-    node.updateLeafNodeCount();
-}
-
-export { deserializeBinaryNode };

package/src/core/bvh2/serialization/deserializeBinaryNodeFromBinaryBuffer.js

@@ -1,90 +0,0 @@
-import { BinaryNode } from "../BinaryNode.js";
-import { LeafNode } from "../LeafNode.js";
-import { deserializeAABB3Encoded_v0 } from "../../geom/3d/aabb/deserializeAABB3Encoded_v0.js";
-import { deserializeAABB3 } from "../../geom/3d/aabb/deserializeAABB3.js";
-
-/**
- *
- * @param {BinaryNode} root
- * @param {BinaryBuffer} buffer
- * @param {function(buffer:BinaryBuffer):*} leafValueDeserializer
- */
-export function deserializeBinaryNodeFromBinaryBuffer(root, buffer, leafValueDeserializer) {
-    //read bounds
-    deserializeAABB3(buffer, root);
-
-    /**
-     *
-     * @param {BinaryNode} parent
-     * @returns {BinaryNode}
-     */
-    function readBinaryNode(parent) {
-
-        const node = new BinaryNode();
-
-        node.parentNode = parent;
-
-        //read bounds
-        deserializeAABB3Encoded_v0(buffer, node, parent.x0, parent.y0, parent.z0, parent.x1, parent.y1, parent.z1);
-
-        //read marker
-        const marker = buffer.readUint8();
-
-        if ((marker & 3) === 3) {
-            node.left = readBinaryNode(node);
-        } else if ((marker & 2) === 2) {
-            node.left = readLeafNode(node);
-        } else {
-            node.left = null;
-        }
-
-        if ((marker & 12) === 12) {
-            node.right = readBinaryNode(node);
-        } else if ((marker & 8) === 8) {
-            node.right = readLeafNode(node);
-        } else {
-            node.right = null;
-        }
-
-        node.updateLeafNodeCount();
-
-        return node;
-    }
-
-    /**
-     *
-     * @param {BinaryNode} parent
-     * @returns {LeafNode}
-     */
-    function readLeafNode(parent) {
-        const node = new LeafNode();
-
-        node.parentNode = parent;
-
-        //read bounds
-        deserializeAABB3Encoded_v0(buffer, node, parent.x0, parent.y0, parent.z0, parent.x1, parent.y1, parent.z1);
-
-        node.object = leafValueDeserializer(buffer);
-
-        return node;
-    }
-
-    //read marker
-    const marker = buffer.readUint8();
-
-    if ((marker & 3) === 3) {
-        root.left = readBinaryNode(root);
-    } else if ((marker & 2) === 2) {
-        root.left = readLeafNode(root);
-    } else {
-        root.left = null;
-    }
-
-    if ((marker & 12) === 12) {
-        root.right = readBinaryNode(root);
-    } else if ((marker & 8) === 8) {
-        root.right = readLeafNode(root);
-    } else {
-        root.right = null;
-    }
-}

package/src/core/bvh2/serialization/serializeBinaryNode.js

@@ -1,31 +0,0 @@
-import {serializeAABB3} from "../../geom/3d/aabb/serializeAABB3.js";
-import {isLeaf, serializeLeafNode} from "../LeafNode.js";
-
-/**
- *
- * @param {BinaryBuffer} buffer
- * @param {BinaryNode} node
- * @param {function(buffer:BinaryBuffer,value:any):void} leafValueSerializer
- */
-function serializeBinaryNode(buffer, node, leafValueSerializer) {
-    serializeAABB3(buffer, node);
-
-    function serializeChild(child) {
-        if (child === null) {
-            buffer.writeUint8(0);
-        } else {
-            if (isLeaf(child)) {
-                buffer.writeUint8(1);
-                serializeLeafNode(buffer, child, leafValueSerializer);
-            } else {
-                buffer.writeUint8(2);
-                serializeBinaryNode(buffer, child, leafValueSerializer);
-            }
-        }
-    }
-
-    serializeChild(node.left);
-    serializeChild(node.right);
-}
-
-export {serializeBinaryNode};

package/src/core/bvh2/serialization/serializeBinaryNodeToBinaryBuffer.js

@@ -1,86 +0,0 @@
-import { serializeAABB3 } from "../../geom/3d/aabb/serializeAABB3.js";
-import { serializeAABB3Encoded_v0 } from "../../geom/3d/aabb/serializeAABB3Encoded_v0.js";
-
-/**
- *
- * @param {BinaryBuffer} buffer
- * @param {BinaryNode} node
- * @param {BinaryNode} parent
- * @param {function(buffer:BinaryBuffer, value:*):void} leafValueSerializer
- */
-function writeBinaryNode(buffer, node, parent, leafValueSerializer) {
-    serializeAABB3Encoded_v0(buffer, node, parent.x0, parent.y0, parent.z0, parent.x1, parent.y1, parent.z1);
-
-    writeBinaryNodeContents(buffer, node, leafValueSerializer);
-}
-
-/**
- *
- * @param {BinaryBuffer} buffer
- * @param {BinaryNode} node
- * @param {function(buffer:BinaryBuffer, value:*):void} leafValueSerializer
- */
-function writeBinaryNodeContents(buffer, node, leafValueSerializer) {
-
-    //build header marker for the node
-    let marker = 0;
-
-    const right = node.right;
-
-    if (right !== null) {
-        if (right.isLeafNode) {
-            marker |= 8;
-        } else {
-            marker |= 12;
-        }
-    }
-
-    const left = node.left;
-
-    if (left !== null) {
-        if (left.isLeafNode) {
-            marker |= 2;
-        } else {
-            marker |= 3;
-        }
-    }
-
-    buffer.writeUint8(marker);
-
-    if ((marker & 3) === 3) {
-        writeBinaryNode(buffer, left, node, leafValueSerializer);
-    } else if ((marker & 2) === 2) {
-        writeLeafNode(buffer, left, node, leafValueSerializer);
-    }
-
-    if ((marker & 12) === 12) {
-        writeBinaryNode(buffer, right, node, leafValueSerializer);
-    } else if ((marker & 8) === 8) {
-        writeLeafNode(buffer, right, node, leafValueSerializer);
-    }
-}
-
-/**
- *
- * @param {BinaryBuffer} buffer
- * @param {LeafNode} node
- * @param {BinaryNode} parent
- * @param {function(buffer:BinaryBuffer, value:*):void} leafValueSerializer
- */
-function writeLeafNode(buffer, node, parent, leafValueSerializer) {
-    serializeAABB3Encoded_v0(buffer, node, parent.x0, parent.y0, parent.z0, parent.x1, parent.y1, parent.z1);
-    leafValueSerializer(buffer, node.object);
-}
-
-/**
- * Writing is lossy, all descendants have their bounds quantized to uin16
- * @param {BinaryNode} root
- * @param {BinaryBuffer} buffer
- * @param {function(buffer:BinaryBuffer, value:*):void} leafValueSerializer
- */
-export function serializeBinaryNodeToBinaryBuffer(root, buffer, leafValueSerializer) {
-    //write initial size
-    serializeAABB3(buffer, root);
-
-    writeBinaryNodeContents(buffer, root, leafValueSerializer);
-}