@woosh/meep-engine 2.67.0 → 2.69.0

package/src/core/bvh2/transform/RotationOptimizer.spec.js

@@ -1,303 +0,0 @@
-import { seededRandom } from "../../math/random/seededRandom.js";
-import { BinaryNode } from "../BinaryNode.js";
-import { isLeaf, LeafNode } from "../LeafNode.js";
-import { validateNode, validateTree } from "../NodeValidator.js";
-import { optimize } from "./RotationOptimizer.js";
-
-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
-        };
-    }
-});
-
-/**
- *
- * @param {number} v0
- * @param {number} v1
- * @param {*} [value]
- * @returns {LeafNode}
- */
-function leaf(v0, v1, value) {
-    const leafNode = new LeafNode(value, v0, v0, v0, v1, v1, v1);
-    return leafNode;
-}
-
-/**
- *
- * @param {NodeDescription} left
- * @param {NodeDescription} right
- * @returns {BinaryNode}
- */
-function pair(left, right) {
-    const node = new BinaryNode();
-
-    if (left === null) {
-        node.right = right;
-        right.parentNode = node;
-        node.refit();
-    } else if (right === null) {
-        node.left = left;
-        left.parentNode = left;
-        node.refit();
-    } else {
-        node.setChildren(left, right);
-    }
-    return node;
-}
-
-
-describe.skip("suite", () => {
-
-
-    test("empty node", () => {
-        const node = new BinaryNode();
-        node.setInfiniteBounds();
-
-        optimize(node, 100);
-
-        expect(node.left).toBeNull();
-        expect(node.right).toBeNull();
-    });
-
-    test("does nothing on optimal 2 child tree", () => {
-        const a = leaf(0, 1, "hello");
-        const b = leaf(2, 3, "goodbye");
-
-        const root = pair(a, b);
-
-        const optimized = optimize(root, 100);
-        expect(optimized).toBe(0);
-
-        //positions preserved
-        expect(root.left.object).toEqual(a.object);
-        expect(root.right.object).toEqual(b.object);
-
-        //parent node is root
-        expect(root.left.parentNode).toEqual(root);
-        expect(root.right.parentNode).toEqual(root);
-
-        expect(root).toBeValid();
-    });
-
-    test("does nothing on optimal depth 2 tree", () => {
-        const a = leaf(-2, -1, "a");
-        const b = leaf(-1, 0, "b");
-        const c = leaf(0, 1, "c");
-        const d = leaf(1, 2, "d");
-
-        const n0 = pair(a, b);
-        const n1 = pair(c, d);
-
-        const root = pair(n0, n1);
-
-        const optimized = optimize(root, 100);
-        expect(optimized).toBe(0);
-
-        expect(root.parentNode).toBeNull();
-
-        expect(root.left).toBe(n0);
-        expect(root.right).toBe(n1);
-
-        expect(n0.left).toBe(a);
-        expect(n0.right).toBe(b);
-
-        expect(n1.left).toBe(c);
-        expect(n1.right).toBe(d);
-
-        expect(root).toBeValid();
-    });
-
-    test("produces a valid tree from left-leaning tree with 4 leaves", () => {
-        const a = leaf(-2, -1, "a");
-        const b = leaf(-1, 0, "b");
-        const c = leaf(0, 1, "c");
-        const d = leaf(1, 2, "d");
-
-        const root = pair(
-            pair(
-                pair(c, d),
-                b
-            ),
-            a
-        );
-
-        optimize(root, 100);
-
-        expect(root).toBeValid();
-
-        expect(root).toContainNode(a);
-        expect(root).toContainNode(b);
-        expect(root).toContainNode(c);
-        expect(root).toContainNode(d);
-    });
-
-    test("produces a valid tree from right-leaning tree with 4 leaves", () => {
-        const a = leaf(-2, -1, "a");
-        const b = leaf(-1, 0, "b");
-        const c = leaf(0, 1, "c");
-        const d = leaf(1, 2, "d");
-
-        const root = pair(
-            a,
-            pair(
-                b,
-                pair(c, d)
-            )
-        );
-
-        optimize(root, 100);
-
-        expect(root).toBeValid();
-
-        expect(root).toContainNode(a);
-        expect(root).toContainNode(b);
-        expect(root).toContainNode(c);
-        expect(root).toContainNode(d);
-    });
-
-    test("100 node random tree optimization does not degrade quality", () => {
-        const random = seededRandom(42);
-
-        const nodes = [];
-
-        for (let i = 0; i < 100; i++) {
-            const x0 = random() * 100;
-            const y0 = random() * 100;
-            const z0 = random() * 100;
-
-            const x1 = x0 + random() * 5;
-            const y1 = y0 + random() * 5;
-            const z1 = z0 + random() * 5;
-
-            nodes.push(new LeafNode(i, x0, y0, z0, x1, y1, z1));
-        }
-
-        while (nodes.length >= 2) {
-            const left = nodes.pop();
-            const right = nodes.pop();
-            nodes.unshift(pair(left, right));
-        }
-
-        const root = nodes[0];
-
-        const oldSAH = root.computeSAH();
-
-        optimize(root, 100);
-
-        expect(root).toBeValid();
-
-        const newSAH = root.computeSAH();
-
-        //at least not degraded
-        expect(newSAH).toBeLessThanOrEqual(oldSAH);
-    });
-
-    test("case 0:  4 node tree optimization does not degrade quality", () => {
-        const ll = new LeafNode("ll",
-            76.06244471671744,
-            7.73902752171125,
-            1.925105413576489,
-            94.49883157197291,
-            50.63123012084361,
-            76.75841101302467
-        );
-
-        const lr = new LeafNode("lr",
-            76.11310176957886,
-            58.65097077867176,
-            11.346076624795387,
-            97.55653706044541,
-            89.91247777413719,
-            90.73181902923352
-        );
-
-        const rl = new LeafNode("rl",
-            32.4771196630536,
-            0.9366270797727339,
-            1.378434756588831,
-            66.71670340545461,
-            99.32784918828929,
-            97.52435446605432
-        );
-
-        const rr = new LeafNode("rr",
-            1.124263022938976,
-            0.13232239543867763,
-            2.702786005283997,
-            31.51776058888572,
-            94.87720282424561,
-            101.03932220629758
-        );
-
-        const root = pair(pair(ll, lr), pair(rl, rr));
-
-        expect(root).toBeValid();
-
-        const oldSAH = root.computeSAH();
-
-        optimize(root, 1000);
-
-        expect(root).toBeValid();
-
-        const newSAH = root.computeSAH();
-
-        //at least not degraded
-        expect(newSAH).toBeLessThanOrEqual(oldSAH);
-    });
-
-})

package/src/core/bvh2/transform/tryRotateSingleNode.js

@@ -1,260 +0,0 @@
-import { surfaceAreaHeuristic as sah } from "../sah/surfaceAreaHeuristic.js";
-import { isLeaf } from "../LeafNode.js";
-import { aabb3_score_boxes_SAH as computeAreaFor2 } from "../../geom/3d/aabb/aabb3_score_boxes_SAH.js";
-import { aabb3_box_surface_area_2 as computeArea } from "../../geom/3d/aabb/aabb3_box_surface_area_2.js";
-
-/**
- *
- * @param {Node} node
- * @param {BinaryNode} parent
- */
-function setParent(node, parent) {
-    node.parentNode = parent;
-}
-
-/**
- * Based on paper "Fast, Effective BVH Updates for Animated Scenes" Kopta et. al. (url: http://www.cs.utah.edu/~thiago/papers/rotations.pdf)
- * @param {BinaryNode} node
- * @returns {int} value from 0 to 6, 0 means no rotation has taken place
- */
-export function tryRotateSingleNode(node) {
-
-    const left = node.left;
-    const right = node.right;
-
-    if (left === null || right === null) {
-        return 0;
-    }
-
-    /*
-     First we compute best rotation to apply, enumerated by 0-6
-     */
-
-    let bestRotation = 0;
-
-
-    const nodeArea = computeArea(node);
-    const leftArea = computeArea(left);
-    const rightArea = computeArea(right);
-
-    const leftLeaves = left.leafNodeCount;
-    const rightLeaves = right.leafNodeCount;
-
-
-    let bestCost = sah(
-        nodeArea,
-        leftArea,
-        rightArea,
-        leftLeaves,
-        rightLeaves
-    );
-
-    let candidateCost;
-
-    let leftLeftArea,
-        leftRightArea,
-        rightLeftArea,
-        rightRightArea;
-
-    let leftLeft,
-        leftRight,
-        rightLeft,
-        rightRight;
-
-    let leftLeftLeaves,
-        leftRightLeaves,
-        rightLeftLeaves,
-        rightRightLeaves;
-
-    let considerLeft = !isLeaf(left);
-
-    if (considerLeft) {
-        leftLeft = left.left;
-        leftRight = left.right;
-
-        considerLeft = (leftLeft !== null && leftRight !== null);
-        if (considerLeft) {
-
-            leftLeftArea = computeArea(leftLeft);
-            leftRightArea = computeArea(leftRight);
-
-            leftLeftLeaves = leftLeft.leafNodeCount;
-            leftRightLeaves = leftRight.leafNodeCount;
-
-            // (1)    N                     N      //
-            //       / \                   / \     //
-            //      L   R     ----->      L   LL   //
-            //     / \                   / \       //
-            //   LL   LR                R   LR     //
-            candidateCost = sah(nodeArea, computeAreaFor2(right, leftRight), leftLeftArea, rightLeaves + leftRightLeaves, leftLeftLeaves);
-
-            if (candidateCost < bestCost) {
-                bestRotation = 1;
-                bestCost = candidateCost;
-            }
-
-            // (2)    N                     N      //
-            //       / \                   / \     //
-            //      L   R     ----->      L   LR   //
-            //     / \                   / \       //
-            //   LL   LR               LL   R      //
-            candidateCost = sah(nodeArea, computeAreaFor2(leftLeft, right), leftRightArea, leftLeftLeaves + rightLeaves, leftRightLeaves);
-
-
-            if (candidateCost < bestCost) {
-                bestRotation = 2;
-                bestCost = candidateCost;
-            }
-        }
-    }
-    if (!isLeaf(right)) {
-        rightLeft = right.left;
-        rightRight = right.right;
-        if (rightLeft !== null && rightRight !== null) {
-
-            rightLeftArea = computeArea(rightLeft);
-            rightRightArea = computeArea(rightRight);
-
-            rightLeftLeaves = rightLeft.leafNodeCount;
-            rightRightLeaves = rightRight.leafNodeCount;
-
-            // (3)    N                     N        //
-            //       / \                   / \       //
-            //      L   R     ----->     RL   R      //
-            //         / \                   / \     //
-            //       RL   RR                L   RR   //
-            candidateCost = sah(nodeArea, rightLeftArea, computeAreaFor2(left, rightRight), rightLeftLeaves, leftLeaves + rightRightLeaves);
-
-            if (candidateCost < bestCost) {
-                bestRotation = 3;
-                bestCost = candidateCost;
-            }
-
-            // (4)    N                     N       //
-            //       / \                   / \      //
-            //      L   R     ----->     RR   R     //
-            //         / \                   / \    //
-            //       RL   RR               RL   L   //
-            candidateCost = sah(nodeArea, rightRightArea, computeAreaFor2(rightLeft, left), rightRightLeaves, rightLeftLeaves + leftLeaves);
-
-
-            if (candidateCost < bestCost) {
-                bestRotation = 4;
-                bestCost = candidateCost;
-            }
-
-            if (considerLeft) {
-                //both child nodes are not leaf
-
-                // (5)       N                      N        //
-                //         /   \                  /   \      //
-                //        L     R     ----->     L     R     //
-                //       / \   / \              / \   / \    //
-                //      LL LR RL RR            LL RL LR RR   //
-                candidateCost = sah(
-                    nodeArea,
-                    computeAreaFor2(leftLeft, rightLeft),
-                    computeAreaFor2(leftRight, rightRight),
-                    leftLeftLeaves + rightLeftLeaves,
-                    leftRightLeaves + rightRightLeaves
-                );
-
-
-                if (candidateCost < bestCost) {
-                    bestRotation = 5;
-                    bestCost = candidateCost;
-                }
-
-                // (6)       N                      N        //
-                //         /   \                  /   \      //
-                //        L     R     ----->     L     R     //
-                //       / \   / \              / \   / \    //
-                //      LL LR RL RR            LL RR RL LR   //
-                candidateCost = sah(
-                    nodeArea,
-                    computeAreaFor2(leftLeft, rightRight),
-                    computeAreaFor2(rightLeft, leftRight),
-                    leftLeftLeaves + rightRightLeaves,
-                    rightLeftLeaves + leftRightLeaves
-                );
-
-                if (candidateCost < bestCost) {
-                    bestRotation = 6;
-                }
-            }
-        }
-    }
-
-    switch (bestRotation) {
-        case 0:
-            //no rotation
-            break;
-        case 1:
-            node.right = leftLeft;
-            setParent(leftLeft, node);
-            left.left = right;
-            setParent(right, left);
-
-            left.refit();
-            //update leaf count
-            node.left.updateLeafNodeCount();
-            break;
-        case 2:
-            node.right = leftRight;
-            setParent(leftRight, node);
-            left.right = right;
-            setParent(right, left);
-
-            left.refit();
-            //update leaf count
-            node.left.updateLeafNodeCount();
-            break;
-        case 3:
-            node.left = rightLeft;
-            setParent(rightLeft, node);
-            right.left = left;
-            setParent(left, right);
-
-            right.refit();
-            //update leaf count
-            node.right.updateLeafNodeCount();
-            break;
-        case 4:
-            node.left = rightRight;
-            setParent(rightRight, node);
-            right.right = left;
-            setParent(left, right);
-
-            right.refit();
-            //update leaf count
-            node.right.updateLeafNodeCount();
-            break;
-        case 5:
-            left.right = rightLeft;
-            setParent(rightLeft, left);
-            right.left = leftRight;
-            setParent(leftRight, right);
-
-            left.refit();
-            right.refit();
-
-            //update leaf count
-            node.left.updateLeafNodeCount();
-            node.right.updateLeafNodeCount();
-            break;
-        case 6:
-            left.right = rightRight;
-            setParent(rightRight, left);
-            right.right = leftRight;
-            setParent(leftRight, right);
-
-            left.refit();
-            right.refit();
-            //update leaf count
-            node.left.updateLeafNodeCount();
-            node.right.updateLeafNodeCount();
-            break;
-    }
-
-    return bestRotation;
-}

package/src/core/bvh2/traversal/BVHVisitor.js

@@ -1,30 +0,0 @@
-export class BVHVisitor {
-    constructor() {
-
-    }
-
-    initialize() {
-
-    }
-
-    finalize() {
-
-    }
-
-    /**
-     *
-     * @param {LeafNode} node
-     */
-    visitLeaf(node) {
-
-    }
-
-    /**
-     *
-     * @param {BinaryNode} node
-     * @returns {boolean} true if traversal should go deeper, false to exclude descendants from traversal
-     */
-    visitBinary(node) {
-        return true;
-    }
-}

package/src/core/bvh2/traversal/RaycastBVHVisitor.js

@@ -1,66 +0,0 @@
-import { BVHVisitor } from "./BVHVisitor.js";
-
-export class RaycastBVHVisitor extends BVHVisitor {
-    constructor() {
-        super();
-
-        this.originX = 0;
-        this.originY = 0;
-        this.originZ = 0;
-
-        this.directionX = 0;
-        this.directionY = 0;
-        this.directionZ = 0;
-
-        /**
-         *
-         * @type {BVHVisitor}
-         */
-        this.collector = null;
-    }
-
-    /**
-     *
-     * @param {number} x
-     * @param {number} y
-     * @param {number} z
-     */
-    setOrigin(x, y, z) {
-        this.originX = x;
-        this.originY = y;
-        this.originZ = z;
-    }
-
-    /**
-     *
-     * @param {number} x
-     * @param {number} y
-     * @param {number} z
-     */
-    setDirection(x, y, z) {
-        this.directionX = x;
-        this.directionY = y;
-        this.directionZ = z;
-    }
-
-    visitLeaf(node) {
-
-        const b = node.intersectRay(this.originX, this.originY, this.originZ, this.directionX, this.directionY, this.directionZ);
-
-
-        if (b) {
-            this.collector.visitLeaf(node);
-        }
-
-    }
-
-    visitBinary(node) {
-        const b = node.intersectRay(this.originX, this.originY, this.originZ, this.directionX, this.directionY, this.directionZ);
-
-        if (b) {
-            this.collector.visitBinary(node);
-        }
-
-        return b;
-    }
-}