@woosh/meep-engine 2.66.0 → 2.68.0

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

@@ -1,77 +0,0 @@
-import { aabb3_intersects_frustum_degree } from "../../geom/3d/aabb/aabb3_intersects_frustum_degree.js";
-import { queryBinaryNode_CollectData } from "./queryBinaryNode_CollectData.js";
-
-/**
- *
- * @type {(BinaryNode|LeafNode)[]}
- */
-const stack = [];
-
-
-/**
- * @template T
- * @param {T[]} destination
- * @param {number} destination_offset
- * @param {BinaryNode<T>} root
- * @param {ArrayLike<number>|number[]|Float32Array} frustum
- * @returns {number} Number of results
- */
-export function queryBinaryNode_FrustumIntersections_Data(destination, destination_offset, root, frustum) {
-
-    /**
-     * @type {BinaryNode<T>|LeafNode<T>}
-     */
-    let n;
-    let offset = destination_offset;
-    let stackPointer = 1;
-
-    stack[0] = root;
-
-    while (stackPointer > 0) {
-
-        stackPointer--;
-
-        n = stack[stackPointer];
-
-        const intersection_degree = aabb3_intersects_frustum_degree(
-            n.x0, n.y0, n.z0,
-            n.x1, n.y1, n.z1,
-            frustum
-        );
-
-        if (intersection_degree === 2) {
-            // fully inside
-
-            offset += queryBinaryNode_CollectData(destination, offset, n);
-
-        } else if (intersection_degree === 1) {
-            // partly inside
-
-            if (n.isBinaryNode === true) {
-
-                const right = n.right;
-
-                if (right !== null) {
-                    stack[stackPointer++] = right;
-                }
-
-                const left = n.left;
-
-                if (left !== null) {
-                    stack[stackPointer++] = left;
-                }
-
-            } else {
-                // leaf node
-
-                destination[offset] = n.object;
-
-                offset++;
-            }
-
-        }
-
-    }
-
-    return offset - destination_offset;
-}

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

@@ -1,63 +0,0 @@
-/**
- *
- * @type {(BinaryNode|LeafNode)[]}
- */
-const stack = [];
-let stackPointer = 0;
-
-
-/**
- * @template T
- * @param {T[]} destination
- * @param {number} destinationOffset
- * @param {BinaryNode<T>} root
- * @param {number} x
- * @param {number} y
- * @param {number} z
- * @param {number} radius
- * @returns {number} Number of results
- */
-export function queryBinaryNode_SphereIntersections_Data(destination, destinationOffset, root, x, y, z, radius) {
-    let n;
-
-    const radius2 = radius * radius;
-
-    const stackOffset = stackPointer;
-
-    stack[stackPointer++] = root;
-
-    let i = 0;
-
-    while (stackPointer-- > stackOffset) {
-
-        n = stack[stackPointer];
-
-        const d2 = n.distanceToPoint2(x, y, z);
-        if (d2 >= radius2) {
-            continue;
-        }
-
-        if (n.isBinaryNode) {
-
-            if (n.right !== null) {
-                stack[stackPointer++] = n.right;
-            }
-
-            if (n.left !== null) {
-                stack[stackPointer++] = n.left;
-            }
-
-        } else {
-
-            destination[destinationOffset + i] = n.object;
-
-            i++;
-        }
-
-    }
-
-    //drop the stack frame
-    stackPointer = stackOffset;
-
-    return i;
-}

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

@@ -1,50 +0,0 @@
-const stack = [];
-let stackPointer = 0;
-
-/**
- *
- * @param {BinaryNode} node
- * @param {BVHVisitor} visitor
- */
-export function traverseBinaryNodeUsingVisitor(node, visitor) {
-    let n;
-
-    const stackOffset = stackPointer;
-
-    stack[stackPointer++] = node;
-
-    while (stackPointer-- > stackOffset) {
-
-        n = stack[stackPointer];
-
-        if (n.isBinaryNode) {
-            const traverseDeeper = visitor.visitBinary(n);
-
-            if (traverseDeeper !== false) {
-
-                if (n.left !== null) {
-
-                    // has a LEFT child
-
-                    stack[stackPointer++] = n.left;
-
-                }
-
-                if (n.right !== null) {
-
-                    // has a RIGHT child
-
-                    stack[stackPointer++] = n.right;
-
-                }
-
-            }
-        } else {
-            visitor.visitLeaf(n);
-        }
-
-    }
-
-    //drop the stack frame
-    stackPointer = stackOffset;
-}

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

@@ -1,34 +0,0 @@
-
-/**
- *
- * @param {BinaryNode} node
- * @param {BVHVisitor} visitor
- */
-export function traverseBinaryNodeUsingVisitor_DepthFirst_PreOrder(node, visitor) {
-    if (node.isBinaryNode) {
-        const traverseDeeper = visitor.visitBinary(node);
-
-        if (traverseDeeper) {
-
-            if (node.left !== null) {
-
-                // has a LEFT child
-
-                traverseBinaryNodeUsingVisitor_DepthFirst_PreOrder(node.left, visitor);
-
-            }
-
-            if (node.right !== null) {
-
-                // has a RIGHT child
-
-                traverseBinaryNodeUsingVisitor_DepthFirst_PreOrder(node.right, visitor);
-
-            }
-
-        }
-
-    } else {
-        visitor.visitLeaf(node);
-    }
-}

package/src/core/bvh2/util/find_least_common_ancestor.js

@@ -1,34 +0,0 @@
-/**
- *
- * @param {BinaryNode} a
- * @param {BinaryNode} b
- * @returns {BinaryNode}
- */
-export function find_least_common_ancestor(a, b) {
-
-    if (a === b) {
-        return a;
-    }
-
-    let n0 = a;
-    let n1 = b;
-
-    while (n0 !== null) {
-
-        n1 = b;
-
-        while (n1 !== null) {
-
-            if (n0 === n1) {
-                return n0;
-            }
-
-            n1 = n1.parentNode;
-        }
-
-        n0 = n0.parentNode;
-    }
-
-    // no common ancestor
-    return null;
-}

package/src/core/bvh2/visual/convert_bvh_to_dot_format_string.js

@@ -1,50 +0,0 @@
-import { convert_graph_to_dot_string } from "../../graph/convert_graph_to_dot_string.js";
-import { bvh_traverse_pre_order_using_stack } from "../traversal/bvh_traverse_pre_order_using_stack.js";
-import { Graph } from "../../graph/v2/Graph.js";
-import { Edge, EdgeDirectionType } from "../../graph/Edge.js";
-
-/**
- *
- * @param {BinaryNode} bvh
- * @returns {Graph}
- */
-export function bvh_to_graph(bvh) {
-    //traverse twice, first collect all nodes, second time introduce edges
-    const graph = new Graph();
-
-    bvh_traverse_pre_order_using_stack(bvh, node => {
-        graph.addNode(node);
-    });
-
-    bvh_traverse_pre_order_using_stack(bvh, node => {
-        if (node.isBinaryNode) {
-
-            if (node.left !== null) {
-                const edge = new Edge(node, node.left);
-
-                edge.direction = EdgeDirectionType.Forward;
-
-                graph.addEdge(edge);
-            }
-            if (node.right !== null) {
-                const edge = new Edge(node, node.right);
-
-                edge.direction = EdgeDirectionType.Forward;
-
-                graph.addEdge(edge);
-            }
-        }
-    });
-
-    return graph;
-}
-
-/**
- * Build a Graphviz DOT representation of the graph
- * @param {BinaryNode} bvh
- * @returns {string}
- */
-export function convert_bvh_to_dot_format_string(bvh) {
-    const graph = bvh_to_graph(bvh);
-    return convert_graph_to_dot_string({ graph: graph });
-}

package/src/core/geom/2d/bvh/BinaryNode2.js

@@ -1,152 +0,0 @@
-import { max2 } from "../../../math/max2.js";
-import { min2 } from "../../../math/min2.js";
-import { Node2 } from "./Node2.js";
-
-function transplantNewCommonParent(node, child) {
-    const bNode = new BinaryNode2();
-    //
-    const parent = node.parentNode;
-    if (node === parent.left) {
-        parent.left = bNode;
-    } else if (node === parent.right) {
-        parent.right = bNode;
-    } else {
-        throw new Error("Not a child of specified parent node(impostor)");
-    }
-    bNode.setChildren(node, child);
-    bNode.parentNode = parent;
-    parent.bubbleExpandToFit(bNode);
-    return bNode;
-}
-
-export class BinaryNode2 extends Node2 {
-    constructor(x0, y0, x1, y1) {
-        super(x0, y0, x1, y1);
-
-
-        /**
-         *
-         * @type {Node2|null}
-         */
-        this.left = null;
-        /**
-         *
-         * @type {Node2|null}
-         */
-        this.right = null;
-    }
-
-    refit() {
-        if (this.left !== null && this.right !== null) {
-            this.refitFor2();
-        } else if (this.left !== null) {
-            this.copy(this.left);
-        } else if (this.right !== null) {
-            this.copy(this.right);
-        }
-    }
-
-    bubbleRefit() {
-        let n = this;
-        while (n !== null) {
-            n.refit();
-            n = n.parentNode;
-        }
-    };
-
-    refitFor2() {
-
-        const a = this.left;
-        const b = this.right;
-
-        this.x0 = min2(a.x0, b.x0);
-        this.y0 = min2(a.y0, b.y0);
-        this.x1 = max2(a.x1, b.x1);
-        this.y1 = max2(a.y1, b.y1);
-    }
-
-    /**
-     *
-     * @param {Node2} left
-     * @param {Node2} right
-     */
-    setChildren(left, right) {
-        this.left = left;
-        this.right = right;
-
-        this.refitFor2();
-
-        left.parentNode = this;
-        right.parentNode = this;
-    }
-
-    /**
-     *
-     * @param {AABB2} box
-     */
-    findParentFor(box) {
-        const a = this.left;
-        const b = this.right;
-
-        if (a === null || b === null) {
-            //unbalanced node, good candidate already
-            return this;
-        }
-
-        let aCost = a.costForInclusion(box);
-        let bCost = b.costForInclusion(box);
-
-        if (aCost === bCost) {
-            //change costs to be surface areas instead
-            aCost = a.computeArea();
-            bCost = b.computeArea();
-        }
-
-        if (aCost < bCost) {
-            if (a.isBinaryNode) {
-                return a.findParentFor(box);
-            } else {
-                return a;
-            }
-        } else if (b.isBinaryNode) {
-            return b.findParentFor(box);
-        } else {
-            return b;
-        }
-    }
-
-    /**
-     *
-     * @param {Node2} child
-     */
-    insertNode(child) {
-        const node = this.findParentFor(child);
-
-        let bNode;
-
-        if (node.isBinaryNode) {
-            if (node.left === null) {
-                node.left = child;
-                child.parentNode = node;
-                node.bubbleExpandToFit(child);
-            } else if (node.right === null) {
-                node.right = child;
-                child.parentNode = node;
-                node.bubbleExpandToFit(child);
-            } else {
-                //take right child and insert another binary node there
-                bNode = new BinaryNode2();
-                bNode.setChildren(node.right, child);
-                //
-                node.right = bNode;
-                bNode.parentNode = node;
-                node.bubbleExpandToFit(bNode);
-            }
-        } else {
-            //need to do transplanting and introduce a new common parent
-            transplantNewCommonParent(node, child);
-        }
-    }
-}
-
-BinaryNode2.prototype.isBinaryNode = true;

package/src/core/geom/2d/bvh/LeafNode2.js

@@ -1,11 +0,0 @@
-import { Node2 } from "./Node2.js";
-
-export class LeafNode2 extends Node2 {
-    constructor(value, x0, y0, x1, y1) {
-        super(x0, y0, x1, y1);
-
-        this.value = value;
-    }
-}
-
-LeafNode2.prototype.isLeafNode = true;

package/src/core/geom/2d/bvh/Node2.js

@@ -1,51 +0,0 @@
-import AABB2 from "../aabb/AABB2.js";
-
-export class Node2 extends AABB2 {
-    constructor(x0, y0, x1, y1) {
-        super(x0, y0, x1, y1);
-
-        /**
-         *
-         * @type {BinaryNode2|null}
-         */
-        this.parentNode = null;
-    }
-
-    /**
-     * Expands current node and all ancestors until root to accommodate for given box, terminate if node is already
-     * large enough
-     * @param {AABB2} box
-     */
-    bubbleExpandToFit(box) {
-        let node = this;
-        while (node.expandToFit(box)) {
-            node = node.parentNode;
-            if (node === null) {
-                break;
-            }
-        }
-    };
-
-    /**
-     * Detaches this node from its parent
-     */
-    disconnect() {
-        const node = this.parentNode;
-
-        if (node === null) {
-            //no parent already
-            console.warn(`Node has no parent, nothing to disconnect from`);
-            return;
-        }
-
-        if (this === node.left) {
-            node.left = null;
-            this.parentNode = null;
-        } else if (this === node.right) {
-            node.right = null;
-            this.parentNode = null;
-        } else {
-            throw new Error("impostor child");
-        }
-    };
-}

package/src/engine/ecs/terrain/tiles/FirstRayIntersectionTerrainBVHVisitor.js

@@ -1,74 +0,0 @@
-import { BVHVisitor } from "../../../../core/bvh2/traversal/BVHVisitor.js";
-import { SurfacePoint3 } from "../../../../core/geom/3d/SurfacePoint3.js";
-
-export class FirstRayIntersectionTerrainBVHVisitor extends BVHVisitor {
-    constructor() {
-        super();
-
-        this.closest = new SurfacePoint3();
-        this.closestDistance = Number.POSITIVE_INFINITY;
-
-        /**
-         *
-         * @type {SurfacePoint3}
-         * @private
-         */
-        this.__tempContact = new SurfacePoint3();
-
-        this.originX = 0;
-        this.originY = 0;
-        this.originZ = 0;
-
-        this.directionX = 0;
-        this.directionY = 0;
-        this.directionZ = 0;
-    }
-
-    /**
-     *
-     * @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;
-    }
-
-    initialize() {
-        this.closestDistance = Number.POSITIVE_INFINITY;
-    }
-
-    visitLeaf(node) {
-
-        /**
-         * @type {TerrainTile}
-         */
-        const tile = node.object;
-
-        if (tile.isBuilt) {
-            const hitDetected = tile.raycastFirstSync(this.__tempContact, this.originX, this.originY, this.originZ, this.directionX, this.directionY, this.directionZ);
-
-            if (hitDetected) {
-                const d = this.__tempContact.position._distanceSqrTo(this.originX, this.originY, this.originZ);
-                if (d < this.closestDistance) {
-                    this.closestDistance = d;
-                    this.closest.copy(this.__tempContact);
-                }
-            }
-        }
-    }
-}

package/src/engine/graphics/geometry/bvh/BVHFromGeometry.js

@@ -1,72 +0,0 @@
-/**
- * Created by Alex on 02/09/2015.
- */
-import { BinaryNode } from '../../../../core/bvh2/BinaryNode.js';
-
-function faceToBox(f, vertices) {
-    const a = vertices[f.a];
-    const b = vertices[f.b];
-    const c = vertices[f.c];
-    //make a box
-    const x0 = Math.min(a.x, b.x, c.x),
-        y0 = Math.min(a.y, b.y, c.y),
-        z0 = Math.min(a.z, b.z, c.z),
-        x1 = Math.max(a.x, b.x, c.x),
-        y1 = Math.max(a.y, b.y, c.y),
-        z1 = Math.max(a.z, b.z, c.z);
-    return {
-        x0: x0,
-        y0: y0,
-        z0: z0,
-        x1: x1,
-        y1: y1,
-        z1: z1,
-        object: f
-    };
-}
-
-function fillTree(faces, vertices, tree) {
-    const numFaces = faces.length;
-    let a, b, c;
-    //make a box
-    let x0, y0, z0, x1, y1, z1;
-    let face;
-
-    function processLeaf(leaf, index) {
-        face = faces[index];
-        a = vertices[face.a];
-        b = vertices[face.b];
-        c = vertices[face.c];
-
-        //make a box
-        x0 = Math.min(a.x, b.x, c.x);
-        y0 = Math.min(a.y, b.y, c.y);
-        z0 = Math.min(a.z, b.z, c.z);
-        x1 = Math.max(a.x, b.x, c.x);
-        y1 = Math.max(a.y, b.y, c.y);
-        z1 = Math.max(a.z, b.z, c.z);
-
-        //set node
-        leaf.setBounds(x0, y0, z0, x1, y1, z1);
-        leaf.object = face;
-    }
-
-    tree.insertManyBoxes2(processLeaf, numFaces);
-}
-
-function bvhFromGeometry(geometry) {
-    //console.time("building geometry bvh");
-    const tree = new BinaryNode();
-    tree.setNegativelyInfiniteBounds();
-    const vertices = geometry.vertices;
-    const faces = geometry.faces;
-
-    fillTree(faces, vertices, tree);
-
-    //console.timeEnd("building geometry bvh");
-    //
-    //console.log("built bvh for " + faces.length + " faces");
-    return tree;
-}
-
-export default bvhFromGeometry;