@woosh/meep-engine 2.67.0 → 2.69.0

package/src/core/bvh2/binary/IndexedBinaryBVHVisitor.js

@@ -1,11 +0,0 @@
-export class IndexedBinaryBVHVisitor {
-    /**
-     *
-     * @param {number} address
-     * @param {NodeType} type
-     * @returns {boolean}
-     */
-    visit(address, type) {
-
-    }
-}

package/src/core/bvh2/binary/NodeType.js

@@ -1,8 +0,0 @@
-/**
- *
- * @enum {number}
- */
-export const NodeType = {
-    LEAF: 0,
-    BINARY: 1
-};

package/src/core/bvh2/binary/RayLeafIntersectionVisitor.js

@@ -1,59 +0,0 @@
-import { noop } from "../../function/Functions.js";
-import { IndexedBinaryBVHVisitor } from "./IndexedBinaryBVHVisitor.js";
-import { NodeType } from "./NodeType.js";
-import { aabb3_intersects_ray } from "../../geom/3d/aabb/aabb3_intersects_ray.js";
-
-export class RayLeafIntersectionVisitor extends IndexedBinaryBVHVisitor {
-    constructor() {
-        super();
-        this.callback = noop;
-        this.callbackThisArg = null;
-
-        this.originX = 0;
-        this.originY = 0;
-        this.originZ = 0;
-
-        this.directionX = 0;
-        this.directionY = 0;
-        this.directionZ = 0;
-
-        /**
-         *
-         * @type {IndexedBinaryBVH}
-         */
-        this.root = null;
-    }
-
-    visit(address, type) {
-        const root = this.root;
-
-        const data = root.data;
-        const binaryNodeCount = root.binaryNodeCount;
-
-        const x0 = data[address];
-        const y0 = data[address + 1];
-        const z0 = data[address + 2];
-        const x1 = data[address + 3];
-        const y1 = data[address + 4];
-        const z1 = data[address + 5];
-
-        const intersectionFound = aabb3_intersects_ray(x0, y0, z0, x1, y1, z1,
-            this.originX, this.originY, this.originZ,
-            this.directionX, this.directionY, this.directionZ
-        );
-
-        if (!intersectionFound) {
-            return false;
-        }
-
-        if (type === NodeType.LEAF) {
-            const value = address / 6 - binaryNodeCount;
-
-            this.callback.call(this.callbackThisArg, value, address, type);
-
-            return false;
-        } else {
-            return true;
-        }
-    }
-}

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

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

@@ -1,144 +0,0 @@
-import { BinaryNode } from "../BinaryNode.js";
-import { isLeaf } from "../LeafNode.js";
-import { surfaceAreaHeuristic } from "../sah/surfaceAreaHeuristic.js";
-import { aabb3_score_boxes_SAH } from "../../geom/3d/aabb/aabb3_score_boxes_SAH.js";
-import { aabb3_box_surface_area_2 } from "../../geom/3d/aabb/aabb3_box_surface_area_2.js";
-
-function BottomUpOptimizingRebuilder() {
-    this.root = null;
-    this.nodes = [];
-    /**
-     * @type {function(left:NodeDescription, right:NodeDescription):number} heuristic Cost function of pairing two nodes, lower value means better pairing
-     */
-    this.heuristic = aabb3_score_boxes_SAH;
-}
-
-/**
- *
- * @param {BinaryNode} root
- */
-BottomUpOptimizingRebuilder.prototype.init = function (root) {
-    this.root = root;
-    const nodes = this.nodes = [];
-    const binaryNodePool = this.binaryNodePool = [];
-
-    //first extract all leaf nodes
-    root.traversePreOrderUsingStack(function (node) {
-        if (isLeaf(node)) {
-            nodes.push(node);
-        } else if (node !== root) {
-            //collect intermediate nodes for reuse
-            binaryNodePool.push(node);
-        }
-    });
-};
-/**
- * Factory to allow reuse of existing node, avoiding garbage collection
- * @returns {BinaryNode}
- */
-BottomUpOptimizingRebuilder.prototype.makeBinaryNode = function () {
-    if (this.binaryNodePool.length > 0) {
-        return this.binaryNodePool.pop();
-    } else {
-        return new BinaryNode();
-    }
-};
-
-/**
- *
- * @param {number} maxSteps
- * @returns {boolean} true when complete
- */
-BottomUpOptimizingRebuilder.prototype.compute = function (maxSteps) {
-    const self = this;
-    /**
-     *
-     * @type {Array.<NodeDescription>}
-     */
-    const nodes = this.nodes;
-
-    let nodeCount = nodes.length;
-
-    const heuristic = this.heuristic;
-
-    let stepsRemaining = maxSteps;
-
-
-    while (nodeCount > 2 && stepsRemaining-- >= 0) {
-        let bestI = -1;
-        let bestJ = -1;
-        let bestCost = Number.POSITIVE_INFINITY;
-        for (let i = 0; i < nodeCount - 1; i++) {
-            const first = nodes[i];
-            for (let j = i + 1; j < nodeCount; j++) {
-                const second = nodes[j];
-
-                const cost = heuristic(first, second);
-
-                if (cost < bestCost) {
-                    bestCost = cost;
-
-                    bestI = i;
-                    bestJ = j;
-                }
-            }
-        }
-
-        const first = nodes[bestI];
-        const second = nodes[bestJ];
-
-        const binaryNode = self.makeBinaryNode();
-        binaryNode.setChildren(first, second);
-
-        //transplant new node in place of the second removed node
-        nodes[bestI] = binaryNode;
-        nodes.splice(bestJ, 1);
-
-        nodeCount--;
-    }
-
-    const root = this.root;
-
-    if (nodeCount === 2) {
-        root.setChildren(nodes[0], nodes[1]);
-        return true;
-    } else if (nodeCount === 1) {
-        root.left = nodes[0];
-        root.left.parentNode = root;
-        root.refit();
-        return true;
-    } else if (nodeCount === 0) {
-        //no nodes, we're done
-        return true;
-    } else {
-        //not done yet
-        return false;
-    }
-};
-
-const leafCounts = new Map();
-
-function leaves(node) {
-    if (leafCounts.has(node)) {
-        return leafCounts.get(node);
-    } else {
-        const count = countLeaves(node);
-        leafCounts.set(node, count);
-        return count;
-    }
-}
-
-function sah(left, right) {
-    const leftArea = aabb3_box_surface_area_2(left);
-    const rightArea = aabb3_box_surface_area_2(right);
-
-    const leftLeaves = leaves(left);
-    const rightLeaves = leaves(right);
-
-    const commonArea = aabb3_score_boxes_SAH(left, right);
-
-    return surfaceAreaHeuristic(commonArea, leftArea, rightArea, leftLeaves, rightLeaves);
-}
-
-
-export { BottomUpOptimizingRebuilder };

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

@@ -1,123 +0,0 @@
-import { BinaryNode } from "../BinaryNode.js";
-import { isLeaf } from "../LeafNode.js";
-import { StacklessTraverser } from "../StacklessTraverser.js";
-import { tryRotateSingleNode } from "./tryRotateSingleNode.js";
-
-
-/**
- *
- * @type {(BinaryNode|LeafNode)[]}
- */
-const stack = [];
-let stackPointer = 0;
-
-/**
- *  * @param {BinaryNode} node
- * @param {Map.<NodeDescription,int>} leafCounts
- */
-function getLeafCount(node, leafCounts) {
-    if (isLeaf(node)) {
-        return 1;
-    }
-
-    let result = 0;
-
-    let n;
-
-    const storedValue = leafCounts.get(node);
-
-    if (storedValue !== undefined) {
-        return storedValue;
-    }
-
-    const stackOffset = stackPointer;
-
-    stack[stackPointer++] = node;
-
-    while (stackPointer-- > stackOffset) {
-
-        n = stack[stackPointer];
-
-
-        const storedValue = leafCounts.get(node);
-
-        if (storedValue !== undefined) {
-            result += storedValue;
-            continue;
-        }
-
-
-        if (n.isBinaryNode) {
-
-            if (n.right !== null) {
-                stack[stackPointer++] = n.right;
-            }
-
-            if (n.left !== null) {
-                stack[stackPointer++] = n.left;
-            }
-
-        } else {
-
-            result++;
-        }
-
-    }
-
-    //drop the stack frame
-    stackPointer = stackOffset;
-
-    leafCounts.set(node, result);
-
-    return result;
-}
-
-/**
- *
- * @param {BinaryNode} root
- * @param {int} maxIterations
- */
-export function optimize(root, maxIterations = 1000) {
-    const traverser = new StacklessTraverser();
-
-    traverser.init(root);
-
-    let changeCounter = 0;
-
-    const leafCounts = new Map();
-
-    function visit(node) {
-
-        if (isLeaf(node)) {
-            //skip leaves
-            return true;
-        }
-
-        const rotationType = tryRotateSingleNode(node, leafCounts);
-        if (rotationType !== 0) {
-            changeCounter++;
-        }
-    }
-
-    let oldChangeCounter = changeCounter;
-
-    let i;
-    for (i = 0; i < maxIterations; i++) {
-        const canAdvance = traverser.advance(visit);
-        if (!canAdvance) {
-            //check if we have made any rotations in this traversal pass
-            if (oldChangeCounter === changeCounter) {
-                //done, no changes
-                break;
-            } else {
-                oldChangeCounter = changeCounter;
-            }
-
-            //re-initialize the traverser
-            traverser.init(root);
-        }
-
-    }
-
-    return changeCounter;
-}