@woosh/meep-engine 2.67.0 → 2.69.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);
-});