@woosh/meep-engine 2.67.0 → 2.69.0

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

@@ -1,281 +0,0 @@
-/**
- * Created by Alex on 24/05/2016.
- */
-import PrimitiveType from "../../binary/type/PrimitiveTypes.js";
-import BinaryStructure from "../../binary/type/Type.js";
-import { aabb3_intersects_ray } from "../../geom/3d/aabb/aabb3_intersects_ray.js";
-
-const NodeType = {
-    LEAF: 0,
-    BINARY: 1
-};
-
-const sBox = new BinaryStructure();
-sBox.addField('x0', PrimitiveType.Float32);
-sBox.addField('y0', PrimitiveType.Float32);
-sBox.addField('z0', PrimitiveType.Float32);
-sBox.addField('x1', PrimitiveType.Float32);
-sBox.addField('y1', PrimitiveType.Float32);
-sBox.addField('z1', PrimitiveType.Float32);
-
-const sNode = sBox.clone();
-sNode.addField('type', PrimitiveType.Uint8);
-
-const sNodeLeaf = sNode.clone();
-sNodeLeaf.addField('index', PrimitiveType.Uint32);
-
-const sNodeBinary = sNode.clone();
-sNodeBinary.addField('left', PrimitiveType.Uint32);
-sNodeBinary.addField('right', PrimitiveType.Uint32);
-
-
-const daNode = sNode.generateDataAccess();
-
-const daNodeLeaf = sNodeLeaf.generateDataAccess();
-const daNodeBinary = sNodeBinary.generateDataAccess();
-
-/**
- *
- * @param leafCount
- * @constructor
- */
-const BinaryBVH = function (leafCount) {
-    const twoLog = Math.log(leafCount) / Math.log(2);
-
-    const twoLeafLimit = Math.pow(2, Math.ceil(twoLog));
-    const binaryNodeCount = twoLeafLimit - 1;
-
-
-    this.nodeByteSize = sNode.byteSize;
-
-    this.leafNodeCount = leafCount;
-    this.leafNodeByteSize = this.nodeByteSize + 4;
-
-    this.binaryNodeByteSize = this.nodeByteSize + 4 * 2;
-
-    this.binaryNodeCount = binaryNodeCount;
-
-    this.leafNodesOffset = this.binaryNodeByteSize * binaryNodeCount;
-
-    this.totalByteSize = this.binaryNodeByteSize * this.binaryNodeCount + this.leafNodeByteSize * this.leafNodeCount;
-
-    this.byteBuffer = new ArrayBuffer(this.totalByteSize);
-    this.dataView = new DataView(this.byteBuffer);
-};
-
-
-function copyBox(from, to, dataView) {
-    const x0 = daNode.read_x0(dataView, from);
-    const y0 = daNode.read_y0(dataView, from);
-    const z0 = daNode.read_z0(dataView, from);
-
-    const x1 = daNode.read_x1(dataView, from);
-    const y1 = daNode.read_y1(dataView, from);
-    const z1 = daNode.read_z1(dataView, from);
-
-    daNode.write_x0(dataView, to, x0);
-    daNode.write_y0(dataView, to, y0);
-    daNode.write_z0(dataView, to, z0);
-
-    daNode.write_x1(dataView, to, x1);
-    daNode.write_y1(dataView, to, y1);
-    daNode.write_z1(dataView, to, z1);
-}
-
-function binaryNodeSetChildren(dataView, binaryNode, childNode0, childNode1) {
-    daNodeBinary.write_type(dataView, binaryNode, NodeType.BINARY);
-    daNodeBinary.write_left(dataView, binaryNode, childNode0);
-    daNodeBinary.write_right(dataView, binaryNode, childNode1);
-}
-
-function binaryNodeRefit(dataView, binaryNode, childNode0, childNode1) {
-
-    const ax0 = daNode.read_x0(dataView, childNode0);
-    const ay0 = daNode.read_y0(dataView, childNode0);
-    const az0 = daNode.read_z0(dataView, childNode0);
-    const ax1 = daNode.read_x1(dataView, childNode0);
-    const ay1 = daNode.read_y1(dataView, childNode0);
-    const az1 = daNode.read_z1(dataView, childNode0);
-
-    const bx0 = daNode.read_x0(dataView, childNode1);
-    const by0 = daNode.read_y0(dataView, childNode1);
-    const bz0 = daNode.read_z0(dataView, childNode1);
-    const bx1 = daNode.read_x1(dataView, childNode1);
-    const by1 = daNode.read_y1(dataView, childNode1);
-    const bz1 = daNode.read_z1(dataView, childNode1);
-
-    const x0 = Math.min(ax0, bx0);
-    const y0 = Math.min(ay0, by0);
-    const z0 = Math.min(az0, bz0);
-
-    const x1 = Math.max(ax1, bx1);
-    const y1 = Math.max(ay1, by1);
-    const z1 = Math.max(az1, bz1);
-
-    daNode.write_x0(dataView, binaryNode, x0);
-    daNode.write_y0(dataView, binaryNode, y0);
-    daNode.write_z0(dataView, binaryNode, z0);
-    daNode.write_x1(dataView, binaryNode, x1);
-    daNode.write_y1(dataView, binaryNode, y1);
-    daNode.write_z1(dataView, binaryNode, z1);
-}
-
-
-BinaryBVH.prototype.unsortedBuiltIntermediate = function () {
-    const dataView = this.dataView;
-
-    const nodeCount = this.binaryNodeCount;
-
-    let level = Math.floor(Math.log(nodeCount) / Math.log(2));
-
-    const leafNodeByteSize = this.leafNodeByteSize;
-    const binaryNodeByteSize = this.binaryNodeByteSize;
-
-    let i, offset, levelNodeCount;
-    //NOTE: building first level separately allows to avoid some switching logic needed to determine what is the type of lower level node
-    //build one level above leaf nodes
-    levelNodeCount = Math.pow(2, level);
-    offset = ((levelNodeCount >> 1) - 1) * binaryNodeByteSize;
-
-
-    for (i = 0; i < levelNodeCount; i++) {
-        const leafIndex0 = i * 2;
-        let leafIndex1 = leafIndex0 + 1;
-
-        let leafOffset0 = this.leafNodesOffset + leafIndex0 * leafNodeByteSize;
-        const leafOffset1 = this.leafNodesOffset + leafIndex1 * leafNodeByteSize;
-
-        if (leafIndex1 >= this.totalByteSize) {
-            leafIndex1 = -1;
-            if (leafOffset0 >= this.totalByteSize) {
-                leafOffset0 = -1;
-            }
-        }
-
-        binaryNodeSetChildren(dataView, offset, leafOffset0, leafIndex1);
-
-        if (leafIndex1 < this.leafNodeCount) {
-            binaryNodeRefit(dataView, offset, leafOffset0, leafOffset1);
-        } else if (leafIndex0 < this.leafNodeCount) {
-            copyBox(leafOffset0, offset, dataView);
-        } else {
-            //don't care about the rest of the nodes
-        }
-
-        offset += binaryNodeByteSize;
-    }
-
-    level--;
-
-    //build intermediate nodes
-    for (; level > 0; level--) {
-        levelNodeCount = Math.pow(2, level);
-        offset = ((levelNodeCount >> 1) - 1) * binaryNodeByteSize;
-
-        const childrenOffset = levelNodeCount * binaryNodeByteSize;
-
-        for (i = 0; i < levelNodeCount; i++) {
-            const childNode0 = childrenOffset + i * 2 * binaryNodeByteSize;
-            const childNode1 = childNode0 + binaryNodeByteSize;
-
-            binaryNodeSetChildren(dataView, offset, childNode0, childNode1);
-            binaryNodeRefit(dataView, offset, childNode0, childNode1);
-
-            offset += binaryNodeByteSize;
-        }
-    }
-
-    //build root
-    binaryNodeSetChildren(dataView, 0, binaryNodeByteSize, binaryNodeByteSize * 2);
-    binaryNodeRefit(dataView, 0, binaryNodeByteSize, binaryNodeByteSize * 2);
-
-    //set bounds of the bvh
-    this.x0 = daNode.read_x0(dataView, 0);
-    this.y0 = daNode.read_y0(dataView, 0);
-    this.z0 = daNode.read_z0(dataView, 0);
-    this.x1 = daNode.read_x1(dataView, 0);
-    this.y1 = daNode.read_y1(dataView, 0);
-    this.z1 = daNode.read_z1(dataView, 0);
-};
-
-BinaryBVH.prototype.setLeaves = function (visitor) {
-
-    const leafNodesOffset = this.leafNodesOffset;
-
-    const leafNodeByteSize = sNodeLeaf.byteSize;
-
-    let byteOffset = leafNodesOffset;
-
-    const dataView = this.dataView;
-
-    let i = 0;
-    const l = this.leafNodeCount;
-    for (; i < l; i++) {
-        const valueToStore = visitor(i, byteOffset, dataView, daNodeLeaf);
-
-        daNodeLeaf.write_type(dataView, byteOffset, NodeType.LEAF);
-        daNodeLeaf.write_index(dataView, byteOffset, valueToStore);
-
-        byteOffset += leafNodeByteSize;
-    }
-    this.unsortedBuiltIntermediate();
-};
-
-BinaryBVH.prototype.traversePreOrder = function (visitor, address, type) {
-    const dataView = this.dataView;
-    const carryOn = visitor(address, type);
-    if (carryOn !== false) {
-
-        const leftAddress = daNodeLeaf.read_left(dataView, address);
-        const rightAddress = daNodeLeaf.read_right(dataView, address);
-        //left
-        if (leftAddress >= 0) {
-            const leftType = daNode.read_type(dataView, leftAddress);
-            if (leftType === NodeType.BINARY) {
-                this.traversePreOrder(visitor, leftAddress, leftType);
-            } else if (leftType === NodeType.LEAF) {
-                visitor(leftAddress, leftType);
-            }
-        }
-        //right
-        if (rightAddress >= 0) {
-            const rightType = daNode.read_type(dataView, rightAddress);
-            if (rightType === NodeType.BINARY) {
-                this.traversePreOrder(visitor, rightAddress, rightType);
-            } else if (rightType === NodeType.LEAF) {
-                visitor(rightAddress, rightType);
-            }
-        }
-    }
-};
-
-BinaryBVH.prototype.traverseRayLeafIntersections = function (startX, startY, startZ, directionX, directionY, directionZ, visitor) {
-
-    const dataView = this.dataView;
-
-    this.traversePreOrder(function (address, type) {
-        const x0 = daNode.read_x0(dataView, address);
-        const y0 = daNode.read_y0(dataView, address);
-        const z0 = daNode.read_z0(dataView, address);
-
-        const x1 = daNode.read_x1(dataView, address);
-        const y1 = daNode.read_y1(dataView, address);
-        const z1 = daNode.read_z1(dataView, address);
-
-        let b = aabb3_intersects_ray(x0, y0, z0, x1, y1, z1, startX, startY, startZ, directionX, directionY, directionZ);
-
-        if (!b) {
-            return false;
-        }
-
-        if (type === NodeType.LEAF) {
-            const value = daNodeLeaf.read_index(dataView, address);
-            visitor(value, address, type);
-            return false;
-        } else {
-            return true;
-        }
-    });
-};
-
-export default BinaryBVH;

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

@@ -1,407 +0,0 @@
-/**
- * Created by Alex on 29/05/2016.
- */
-import { max2 } from "../../math/max2.js";
-import { min2 } from "../../math/min2.js";
-import { IndexedBinaryBVHVisitor } from "./IndexedBinaryBVHVisitor.js";
-import { NodeType } from "./NodeType.js";
-import { RayLeafIntersectionVisitor } from "./RayLeafIntersectionVisitor.js";
-import { array_copy } from "../../collection/array/array_copy.js";
-
-
-/**
- *
- * @type {Float32Array|number[]}
- */
-const scratch_aabb_0 = new Float32Array(6);
-
-
-export default class IndexedBinaryBVH {
-    /**
-     *
-     * @constructor
-     */
-    constructor() {
-        /**
-         *
-         * @type {number}
-         */
-        this.leafNodeCount = 0;
-
-        /**
-         *
-         * @type {number}
-         */
-        this.binaryNodeCount = 0;
-
-        /**
-         * Total number of boxes contained in the tree, some might be unused
-         * @type {number}
-         */
-        this.boxCount = 0;
-
-        /**
-         *
-         * @type {Float32Array|number[]}
-         */
-        this.data = new Float32Array(16);
-    }
-
-    /**
-     *
-     * @returns {number}
-     */
-    estimateByteSize(){
-        return this.data.buffer.byteLength + 248;
-    }
-
-    /**
-     *
-     * @param {int} leafCount
-     */
-    initialize(leafCount) {
-
-        const twoLog = Math.log(leafCount) / Math.log(2);
-
-        const twoLeafLimit = Math.pow(2, Math.ceil(twoLog));
-        const binaryNodeCount = twoLeafLimit - 1;
-
-        this.leafNodeCount = leafCount;
-
-        this.binaryNodeCount = binaryNodeCount;
-
-        this.boxCount = this.leafNodeCount + this.binaryNodeCount;
-
-        // possibly resize the storage
-        const storage_size = this.boxCount * 6;
-
-        if (this.data.length < storage_size) {
-            this.data = new Float32Array(storage_size);
-        } else {
-            this.data.fill(0);
-        }
-    }
-
-    unsortedBuiltIntermediate() {
-        const data = this.data;
-
-        const nodeCount = this.binaryNodeCount;
-
-        const leafNodesOffset = this.binaryNodeCount * 6;
-
-        let level = Math.floor(Math.log(nodeCount) / Math.log(2));
-
-        let i, offset, levelNodeCount;
-        //NOTE: building first level separately allows to avoid some switching logic needed to determine what is the type of lower level node
-        //build one level above leaf nodes
-        levelNodeCount = Math.pow(2, level);
-        offset = (levelNodeCount - 1) * 6;
-
-        let parentIndex, childIndex0, childIndex1;
-
-        for (i = 0; i < levelNodeCount; i++) {
-            const leafIndex0 = i * 2;
-            const leafIndex1 = leafIndex0 + 1;
-
-            const leafOffset0 = leafNodesOffset + leafIndex0 * 6;
-            const leafOffset1 = leafNodesOffset + leafIndex1 * 6;
-
-            if (leafIndex1 < this.leafNodeCount) {
-                binaryNodeRefit(data, offset, leafOffset0, leafOffset1);
-            } else if (leafIndex0 < this.leafNodeCount) {
-                copyBox(leafOffset0, offset, data);
-            } else {
-                //initialize to 0-size box same position as previous node
-                copyBoxZeroSize(offset - 6, offset, data);
-            }
-
-            offset += 6;
-        }
-
-        level--;
-
-        //build intermediate nodes
-        for (; level >= 0; level--) {
-            levelNodeCount = Math.pow(2, level);
-            parentIndex = (levelNodeCount - 1);
-
-            for (i = 0; i < levelNodeCount; i++) {
-
-                childIndex0 = (parentIndex << 1) + 1;
-                childIndex1 = childIndex0 + 1;
-
-                binaryNodeRefit(data, parentIndex * 6, childIndex0 * 6, childIndex1 * 6);
-
-                parentIndex++;
-            }
-        }
-
-        //set bounds of the bvh
-        array_copy(data, 0, scratch_aabb_0, 0, 6);
-
-        this.x0 = scratch_aabb_0[0];
-        this.y0 = scratch_aabb_0[1];
-        this.z0 = scratch_aabb_0[2];
-        this.x1 = scratch_aabb_0[3];
-        this.y1 = scratch_aabb_0[4];
-        this.z1 = scratch_aabb_0[5];
-    }
-
-    /**
-     * Sets bounds of a given leaf
-     * NOTE: to build tree, must call {@link #unsortedBuiltIntermediate} after all leaves are set
-     * @param {number} leaf_index
-     * @param {number} x0
-     * @param {number} y0
-     * @param {number} z0
-     * @param {number} x1
-     * @param {number} y1
-     * @param {number} z1
-     */
-    writeLeaf(leaf_index, x0, y0, z0, x1, y1, z1) {
-        const offset = this.binaryNodeCount * 6 + leaf_index * 6;
-        writeBox(this.data, offset, x0, y0, z0, x1, y1, z1);
-    }
-
-    /**
-     * @template T
-     * @deprecated use {@link #writeLeaf} instead followed by {@link #unsortedBuiltIntermediate}
-     * @param {function(index:number,offset:number,data:T, writeBox:function):void} visitor
-     */
-    setLeafs(visitor) {
-        let offset = this.binaryNodeCount * 6;
-
-        const data = this.data;
-
-        let i = 0;
-        const l = this.leafNodeCount;
-        for (; i < l; i++) {
-            visitor(i, offset, data, writeBox);
-
-            offset += 6;
-        }
-        this.unsortedBuiltIntermediate();
-    }
-
-    /**
-     *
-     * @param {IndexedBinaryBVHVisitor} visitor
-     * @param {Number} startIndex
-     */
-    traversePreOrderStack(visitor, startIndex) {
-
-        const stackOffset = stackPointer;
-
-        stack[stackPointer++] = startIndex;
-
-        const nodeThreshold = this.binaryNodeCount * 6;
-        const endAddress = this.boxCount * 6;
-
-        while (stackPointer-- > stackOffset) {
-
-            const index = stack[stackPointer];
-
-            const address = index * 6;
-
-            const split = visitor.visit(address, NodeType.BINARY);
-            if (split) {
-
-                const leftIndex = (index << 1) + 1;
-                const rightIndex = leftIndex + 1;
-
-                const leftAddress = leftIndex * 6;
-                const rightAddress = rightIndex * 6;
-
-                //right
-                if (rightAddress < endAddress) {
-                    if (rightAddress < nodeThreshold) {
-                        stack[stackPointer++] = rightIndex;
-                    } else {
-                        visitor.visit(rightAddress, NodeType.LEAF);
-                    }
-                }
-
-                //left
-                if (leftAddress < endAddress) {
-                    if (leftAddress < nodeThreshold) {
-                        stack[stackPointer++] = leftIndex;
-                    } else {
-                        visitor.visit(leftAddress, NodeType.LEAF);
-                    }
-                }
-            }
-        }
-
-        //drop stack
-        stackPointer = stackOffset;
-    }
-
-    /**
-     *
-     * @param {function} visitor
-     * @param {number} index
-     * @param {number} type
-     */
-    traversePreOrder(visitor, index, type) {
-        const address = index * 6;
-        const carryOn = visitor(address, type);
-        const nodeThreshold = this.binaryNodeCount * 6;
-        const endAddress = this.boxCount * 6;
-
-        if (carryOn !== false) {
-
-            const leftIndex = (index << 1) + 1;
-            const rightIndex = leftIndex + 1;
-
-            const leftAddress = leftIndex * 6;
-            const rightAddress = rightIndex * 6;
-            //left
-            if (leftAddress < endAddress) {
-                if (leftAddress < nodeThreshold) {
-                    this.traversePreOrder(visitor, leftIndex, NodeType.BINARY);
-                } else {
-                    visitor(leftAddress, NodeType.LEAF);
-                }
-            }
-            //right
-            if (rightAddress < endAddress) {
-                if (rightAddress < nodeThreshold) {
-                    this.traversePreOrder(visitor, rightIndex, NodeType.BINARY);
-                } else {
-                    visitor(rightAddress, NodeType.LEAF);
-                }
-            }
-        }
-    }
-
-    /**
-     * @deprecated use a visitor object instead
-     * @param {number} startX
-     * @param {number} startY
-     * @param {number} startZ
-     * @param {number} directionX
-     * @param {number} directionY
-     * @param {number} directionZ
-     * @param {function} visitor
-     * @param {*} [thisArg]
-     */
-    traverseRayLeafIntersections(startX, startY, startZ, directionX, directionY, directionZ, visitor, thisArg) {
-        rayLeafIntersectionVisitor.originX = startX;
-        rayLeafIntersectionVisitor.originY = startY;
-        rayLeafIntersectionVisitor.originZ = startZ;
-
-        rayLeafIntersectionVisitor.directionX = directionX;
-        rayLeafIntersectionVisitor.directionY = directionY;
-        rayLeafIntersectionVisitor.directionZ = directionZ;
-
-        rayLeafIntersectionVisitor.root = this;
-        rayLeafIntersectionVisitor.callback = visitor;
-        rayLeafIntersectionVisitor.callbackThisArg = thisArg;
-
-        this.traversePreOrderStack(rayLeafIntersectionVisitor, 0);
-    }
-}
-
-/**
- *
- * @param {number[]|Float32Array} source
- * @param {number} source_address_0
- * @param {number} source_address_1
- * @param {number[]|Float32Array} destination
- * @param {number} destination_offset
- */
-function contain_box_array(source, source_address_0, source_address_1, destination, destination_offset) {
-
-    const ax0 = source[source_address_0];
-    const ay0 = source[source_address_0 + 1];
-    const az0 = source[source_address_0 + 2];
-    const ax1 = source[source_address_0 + 3];
-    const ay1 = source[source_address_0 + 4];
-    const az1 = source[source_address_0 + 5];
-
-    const bx0 = source[source_address_1];
-    const by0 = source[source_address_1 + 1];
-    const bz0 = source[source_address_1 + 2];
-    const bx1 = source[source_address_1 + 3];
-    const by1 = source[source_address_1 + 4];
-    const bz1 = source[source_address_1 + 5];
-
-    const x0 = min2(ax0, bx0);
-    const y0 = min2(ay0, by0);
-    const z0 = min2(az0, bz0);
-
-    const x1 = max2(ax1, bx1);
-    const y1 = max2(ay1, by1);
-    const z1 = max2(az1, bz1);
-
-    destination[destination_offset] = x0;
-    destination[destination_offset + 1] = y0;
-    destination[destination_offset + 2] = z0;
-    destination[destination_offset + 3] = x1;
-    destination[destination_offset + 4] = y1;
-    destination[destination_offset + 5] = z1;
-}
-
-/**
- *
- * @param {Float32Array} array
- * @param {number} address
- * @param {number} x0
- * @param {number} y0
- * @param {number} z0
- * @param {number} x1
- * @param {number} y1
- * @param {number} z1
- */
-function writeBox(array, address, x0, y0, z0, x1, y1, z1) {
-    array[address] = x0;
-    array[address + 1] = y0;
-    array[address + 2] = z0;
-    array[address + 3] = x1;
-    array[address + 4] = y1;
-    array[address + 5] = z1;
-}
-
-/**
- *
- * @param {number} from
- * @param {number} to
- * @param {Float32Array} array
- */
-function copyBox(from, to, array) {
-    array_copy(array, from, array, to, 6);
-}
-
-/**
- *
- * @param {number} from
- * @param {number} to
- * @param {Float32Array|number[]} array
- */
-function copyBoxZeroSize(from, to, array) {
-    array_copy(array, from, scratch_aabb_0, 0, 3);
-
-    scratch_aabb_0[3] = scratch_aabb_0[0];
-    scratch_aabb_0[4] = scratch_aabb_0[1];
-    scratch_aabb_0[5] = scratch_aabb_0[2];
-
-    array_copy(scratch_aabb_0, 0, array, to, 6);
-}
-
-/**
- *
- * @param {Float32Array} array
- * @param {number} binaryNode
- * @param {number} childNode0
- * @param {number} childNode1
- */
-function binaryNodeRefit(array, binaryNode, childNode0, childNode1) {
-    contain_box_array(array, childNode0, childNode1, array, binaryNode);
-}
-
-
-const stack = [];
-let stackPointer = 0;
-
-const rayLeafIntersectionVisitor = new RayLeafIntersectionVisitor();
-

package/src/core/bvh2/binary/IndexedBinaryBVH.spec.js

@@ -1,27 +0,0 @@
-import IndexedBinaryBVH from "./IndexedBinaryBVH.js";
-
-test("constructor does not throw", () => {
-    expect(() => new IndexedBinaryBVH()).not.toThrow();
-});
-
-
-test("build a tree with a single leaf", () => {
-    const bvh = new IndexedBinaryBVH();
-
-    bvh.initialize(1);
-    bvh.writeLeaf(0, -1, -3, -7, 11, 13, 17);
-
-    bvh.unsortedBuiltIntermediate();
-
-    expect(bvh.leafNodeCount).toBe(1);
-    expect(bvh.binaryNodeCount).toBe(0);
-
-    expect(bvh.x0).toBe(-1);
-    expect(bvh.y0).toBe(-3);
-    expect(bvh.z0).toBe(-7);
-
-    expect(bvh.x1).toBe(11);
-    expect(bvh.y1).toBe(13);
-    expect(bvh.z1).toBe(17);
-
-});