@woosh/meep-engine 2.66.0 → 2.68.0

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;
-    }
-}