@woosh/meep-engine 2.155.0 → 2.157.0

package/src/core/bvh8/build/NodeProxy.js

@@ -0,0 +1,308 @@
+import { array_remove_first } from "../../collection/array/array_remove_first.js";
+import { aabb3_array_combine } from "../../geom/3d/aabb/aabb3_array_combine.js";
+import { aabb3_compute_surface_area } from "../../geom/3d/aabb/aabb3_compute_surface_area.js";
+import { v3_distance_sqr } from "../../geom/vec3/v3_distance_sqr.js";
+import { BVH8_MAX_LEAF_TRIANGLE_OFFSET } from "../BVH8.js";
+import { aabb3_from_triangle_by_index } from "./aabb3_from_triangle_by_index.js";
+import { TriangleCluster } from "./TriangleCluster.js";
+
+export class NodeProxy {
+
+    /**
+     *
+     * @type {TriangleCluster[]}
+     */
+    primitives = []
+
+    primitive_index_low = 0xFFFFFFFF;
+    primitive_index_high = 0;
+
+    /**
+     *
+     * @type {NodeProxy[]}
+     */
+    children = []
+
+    bounds = new Float32Array([
+        Infinity, Infinity, Infinity,
+        -Infinity, -Infinity, -Infinity
+    ])
+
+    height = 0
+
+    computeHeight() {
+        const children = this.children;
+        const child_count = children.length;
+
+        let height = 0;
+        for (let i = 0; i < child_count; i++) {
+            const child = children[i];
+
+            if (child.height >= height) {
+                height = child.height + 1;
+            }
+        }
+
+        this.height = height;
+    }
+
+    primitive_count = 0;
+
+    /**
+     *
+     * @param {NodeProxy} other
+     * @returns {number}
+     */
+    computeCentroidSqrDistanceTo(other) {
+        const ax = (this.bounds[0] + this.bounds[3]) * 0.5;
+        const ay = (this.bounds[1] + this.bounds[4]) * 0.5;
+        const az = (this.bounds[2] + this.bounds[5]) * 0.5;
+
+        const bx = (other.bounds[0] + other.bounds[3]) * 0.5;
+        const by = (other.bounds[1] + other.bounds[4]) * 0.5;
+        const bz = (other.bounds[2] + other.bounds[5]) * 0.5;
+
+        return v3_distance_sqr(ax, ay, az, bx, by, bz);
+    }
+
+    computePrimitiveBounds(index_array, position_array) {
+        const clusters = this.primitives;
+        const cluster_count = clusters.length;
+        for (let i = 0; i < cluster_count; i++) {
+            clusters[i].computeBounds(index_array, position_array);
+        }
+    }
+
+    /**
+     * A node has 8 slots that can be used for either triangle clusters or children
+     * @returns {number}
+     */
+    get used_slot_count() {
+        return this.primitives.length + this.children.length;
+    }
+
+    recomputePrimitiveSpan() {
+        this.primitive_index_low = 0xFFFFFFFF;
+        this.primitive_index_high = 0;
+
+        for (let i = 0; i < this.primitives.length; i++) {
+            const cluster = this.primitives[i];
+
+            for (let j = 0; j < cluster.triangles.length; j++) {
+                const triangle = cluster.triangles[j];
+
+                this.primitive_index_low = Math.min(triangle, this.primitive_index_low);
+                this.primitive_index_high = Math.max(triangle, this.primitive_index_high);
+            }
+        }
+    }
+
+    /**
+     *
+     * @param {number} index
+     * @param {number[]|Float32Array} bounds
+     * @returns {boolean} true if added, false otherwise
+     */
+    tryAddPrimitive(index, bounds) {
+        const min = Math.min(index, this.primitive_index_low);
+        const max = Math.max(index, this.primitive_index_high);
+
+        if ((max - min) > BVH8_MAX_LEAF_TRIANGLE_OFFSET) {
+            // a leaf meta stores the offset of its first triangle relative to the node's
+            // lowest triangle index; offsets above the cap collide with the internal slot encoding
+            return false;
+        }
+
+        const clusters = this.primitives;
+        const cluster_count = clusters.length;
+
+
+        for (let i = 0; i < cluster_count; i++) {
+            const candidate = clusters[i];
+
+
+            if (candidate.canAccept(index, bounds)) {
+                candidate.add(index, bounds);
+
+                this.primitive_index_low = min;
+                this.primitive_index_high = max;
+
+                return true;
+            }
+        }
+
+        // no candidate found, see if we can create one
+        if (this.used_slot_count === 8) {
+            // at capacity
+            return false;
+        }
+
+        const cluster = new TriangleCluster();
+        cluster.add(index, bounds);
+
+        let insert_position;
+        for (insert_position = 0; insert_position < cluster_count; insert_position++) {
+            // find where to insert new cluster, keeping clusters sorted by first triangle
+            const candidate = clusters[insert_position];
+            if (candidate.triangles[0] > index) {
+                break;
+            }
+        }
+
+        clusters.splice(insert_position, 0, cluster);
+
+        this.primitive_index_low = min;
+        this.primitive_index_high = max;
+
+        return true;
+    }
+
+    addChild(node) {
+        this.children.push(node);
+        this.height = Math.max(this.height, node.height + 1);
+
+        aabb3_array_combine(this.bounds, 0, this.bounds, 0, node.bounds, 0);
+
+        this.primitive_count += node.primitive_count;
+    }
+
+    /**
+     * Attempt to pull up data from children and in process reduce number of nodes below
+     */
+    optimize_pull_up(index_array, position_array) {
+        const children = this.children;
+        for (let i = children.length - 1; i >= 0; i--) {
+            const child = children[i];
+
+            const optimized = this.tryAbsorbChild(child, index_array, position_array);
+
+            if (optimized && child.children.length > 0) {
+                // pull up and try again
+                child.optimize_pull_up(index_array, position_array);
+                i++;
+            }
+        }
+    }
+
+    /**
+     *
+     * @param {NodeProxy} child
+     * @param {number[]} index_array
+     * @param {number[]} position_array
+     * @return {boolean}
+     */
+    tryAbsorbChild(child, index_array, position_array) {
+        const child_clusters = child.primitives;
+        let child_cluster_count = child_clusters.length;
+
+        let absorbed_count = 0;
+
+        for (let i = 0; i < child_cluster_count; i++) {
+            const cluster = child_clusters[i];
+
+            const triangles = cluster.triangles;
+            let cluster_size = triangles.length;
+
+            let retry_middle = false;
+
+            for (let j = 0; j < cluster_size; j++) {
+                const triangle = triangles[j];
+
+                if (j > 0 && j < cluster_size - 1) {
+                    // triangle in the middle, can't remove
+                    // triangles are indexed sequentially, gaps are not valid
+                    retry_middle = true;
+                    continue;
+                }
+
+                const bounds = [];
+                aabb3_from_triangle_by_index(bounds, 0, triangle, index_array, position_array);
+
+                if (this.tryAddPrimitive(triangle, bounds)) {
+                    triangles.splice(j, 1);
+
+                    child.primitive_count--;
+
+                    absorbed_count++;
+
+                    j--;
+                    cluster_size--;
+
+                    if (retry_middle) {
+                        j--;
+                    }
+                }
+            }
+
+            if (cluster_size === 0) {
+                child_clusters.splice(i, 1);
+
+                i--;
+                child_cluster_count--;
+
+            }
+        }
+
+        if (absorbed_count <= 0) {
+            // nothing absorbed, we're done
+            return false;
+        }
+
+        child.recomputePrimitiveSpan();
+
+        if (child_cluster_count === 0 && child.children.length === 0) {
+            // dead child
+            array_remove_first(this.children, child);
+
+            if (child.height >= this.height - 1) {
+                // should recompute height
+                this.computeHeight();
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Mostly useful for debug
+     * @param {number} index
+     * @returns {undefined|NodeProxy}
+     */
+    findNodeByPrimitive(index) {
+        const clusters = this.primitives;
+        for (let i = 0; i < clusters.length; i++) {
+            if (clusters[i].contains(index)) {
+                return this;
+            }
+        }
+
+        const children = this.children;
+        for (let i = 0; i < children.length; i++) {
+            const found = children[i].findNodeByPrimitive(index);
+
+            if (found !== undefined) {
+                return found;
+            }
+        }
+
+        // not found
+        return undefined;
+    }
+
+    /**
+     * Heuristic score of how good the tree is
+     * Lower = better
+     * @return {number}
+     */
+    area_score() {
+        let result = aabb3_compute_surface_area(...this.bounds);
+
+        for (const child of this.children) {
+            result += child.area_score();
+        }
+
+        return result;
+    }
+}
+
+NodeProxy.prototype.isNodeProxy = true;

package/src/core/bvh8/build/TriangleCluster.d.ts

@@ -0,0 +1,29 @@
+export class TriangleCluster {
+    /**
+     *
+     * @type {number[]}
+     */
+    triangles: number[];
+    bounds: Float32Array;
+    computeBounds(index_array: any, position_array: any): void;
+    /**
+     *
+     * @param {number} index
+     * @returns {boolean}
+     */
+    contains(index: number): boolean;
+    /**
+     *
+     * @param {number} index
+     * @param {number[]} bounds
+     */
+    add(index: number, bounds: number[]): void;
+    /**
+     *
+     * @param {number} index
+     * @param {number[]} bounds
+     * @returns {boolean}
+     */
+    canAccept(index: number, bounds: number[]): boolean;
+}
+//# sourceMappingURL=TriangleCluster.d.ts.map

package/src/core/bvh8/build/TriangleCluster.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TriangleCluster.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh8/build/TriangleCluster.js"],"names":[],"mappings":"AAGA;IACI;;;OAGG;IACH,WAFU,MAAM,EAAE,CAEH;IACf,qBAA6B;IAE7B,2DA6CC;IAED;;;;OAIG;IACH,gBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;OAIG;IACH,WAHW,MAAM,UACN,MAAM,EAAE,QAWlB;IAED;;;;;OAKG;IACH,iBAJW,MAAM,UACN,MAAM,EAAE,GACN,OAAO,CAkCnB;CACJ"}

package/src/core/bvh8/build/TriangleCluster.js

@@ -0,0 +1,123 @@
+import { aabb3_array_combine } from "../../geom/3d/aabb/aabb3_array_combine.js";
+import { aabb3_array_set } from "../../geom/3d/aabb/aabb3_array_set.js";
+
+export class TriangleCluster {
+    /**
+     *
+     * @type {number[]}
+     */
+    triangles = [];
+    bounds = new Float32Array(6);
+
+    computeBounds(index_array, position_array) {
+        let min_x = Infinity;
+        let min_y = Infinity;
+        let min_z = Infinity;
+
+        let max_x = -Infinity;
+        let max_y = -Infinity;
+        let max_z = -Infinity;
+
+        const primitives = this.triangles;
+        const primitive_count = primitives.length;
+
+        for (let i = 0; i < primitive_count; i++) {
+            const triangle = primitives[i];
+
+            const a = index_array[triangle * 3];
+            const b = index_array[triangle * 3 + 1];
+            const c = index_array[triangle * 3 + 2];
+
+            const ax = position_array[a * 3];
+            const ay = position_array[a * 3 + 1];
+            const az = position_array[a * 3 + 2];
+
+            const bx = position_array[b * 3];
+            const by = position_array[b * 3 + 1];
+            const bz = position_array[b * 3 + 2];
+
+            const cx = position_array[c * 3];
+            const cy = position_array[c * 3 + 1];
+            const cz = position_array[c * 3 + 2];
+
+            min_x = Math.min(min_x, ax, bx, cx);
+            min_y = Math.min(min_y, ay, by, cy);
+            min_z = Math.min(min_z, az, bz, cz);
+
+            max_x = Math.max(max_x, ax, bx, cx);
+            max_y = Math.max(max_y, ay, by, cy);
+            max_z = Math.max(max_z, az, bz, cz);
+        }
+
+        aabb3_array_set(
+            this.bounds, 0,
+            min_x, min_y, min_z,
+            max_x, max_y, max_z,
+        );
+    }
+
+    /**
+     *
+     * @param {number} index
+     * @returns {boolean}
+     */
+    contains(index) {
+        return this.triangles.includes(index);
+    }
+
+    /**
+     *
+     * @param {number} index
+     * @param {number[]} bounds
+     */
+    add(index, bounds) {
+        this.triangles.push(index);
+
+        // update bounds
+        if (this.triangles.length === 1) {
+            this.bounds.set(bounds);
+        } else {
+            aabb3_array_combine(this.bounds, 0, this.bounds, 0, bounds, 0);
+        }
+    }
+
+    /**
+     *
+     * @param {number} index
+     * @param {number[]} bounds
+     * @returns {boolean}
+     */
+    canAccept(index, bounds) {
+        const triangles = this.triangles;
+        const current_count = triangles.length;
+
+        if (current_count === 0) {
+            // currently empty, no problem
+            return true;
+        } else if (current_count === 3) {
+            // full
+            return false;
+        }
+
+        if (current_count === 1) {
+            const existing = triangles[0];
+            if (Math.abs(existing - index) > 1) {
+                // indices too far apart
+                return false;
+            }
+        } else if (current_count === 2) {
+            const v0 = triangles[0];
+            const v1 = triangles[1];
+
+            const min = Math.min(v0, v1, index);
+            const max = Math.max(v0, v1, index);
+
+            if ((max - min) > 2) {
+                // new index is too far out
+                return false;
+            }
+        }
+
+        return true;
+    }
+}

package/src/core/bvh8/build/aabb3_compute_merge_cost.d.ts

@@ -0,0 +1,8 @@
+/**
+ *
+ * @param {number[]} a
+ * @param {number[]} b
+ * @retunrs {number}
+ */
+export function aabb3_compute_merge_cost(a: number[], b: number[]): number;
+//# sourceMappingURL=aabb3_compute_merge_cost.d.ts.map

package/src/core/bvh8/build/aabb3_compute_merge_cost.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aabb3_compute_merge_cost.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh8/build/aabb3_compute_merge_cost.js"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH,4CAJW,MAAM,EAAE,KACR,MAAM,EAAE,UAoBlB"}

package/src/core/bvh8/build/aabb3_compute_merge_cost.js

@@ -0,0 +1,29 @@
+import { aabb3_array_combine } from "../../geom/3d/aabb/aabb3_array_combine.js";
+import { aabb3_compute_surface_area } from "../../geom/3d/aabb/aabb3_compute_surface_area.js";
+
+const scratch_aabb = new Float32Array(6);
+
+/**
+ *
+ * @param {number[]} a
+ * @param {number[]} b
+ * @retunrs {number}
+ */
+export function aabb3_compute_merge_cost(a, b) {
+
+    const area_a = aabb3_compute_surface_area(...a);
+    const area_b = aabb3_compute_surface_area(...b);
+
+    const area_sum = area_a + area_b;
+
+    if (area_sum === 0) {
+        // avoid division by 0
+        return 1;
+    }
+
+    aabb3_array_combine(scratch_aabb, 0, a, 0, b, 0);
+
+    const combined_area = aabb3_compute_surface_area(...scratch_aabb);
+
+    return combined_area / area_sum;
+}

package/src/core/bvh8/build/aabb3_from_triangle_by_index.d.ts

@@ -0,0 +1,10 @@
+/**
+ *
+ * @param {number[]|Float32Array} output
+ * @param {number} output_offset
+ * @param {number} index
+ * @param {number[]} index_array
+ * @param {number[]} position_array
+ */
+export function aabb3_from_triangle_by_index(output: number[] | Float32Array, output_offset: number, index: number, index_array: number[], position_array: number[]): void;
+//# sourceMappingURL=aabb3_from_triangle_by_index.d.ts.map

package/src/core/bvh8/build/aabb3_from_triangle_by_index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aabb3_from_triangle_by_index.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh8/build/aabb3_from_triangle_by_index.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,qDANW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,SACN,MAAM,eACN,MAAM,EAAE,kBACR,MAAM,EAAE,QASlB"}

package/src/core/bvh8/build/aabb3_from_triangle_by_index.js

@@ -0,0 +1,18 @@
+import { aabb3_compute_from_triangle } from "../../geom/3d/triangle/aabb3_compute_from_triangle.js";
+
+/**
+ *
+ * @param {number[]|Float32Array} output
+ * @param {number} output_offset
+ * @param {number} index
+ * @param {number[]} index_array
+ * @param {number[]} position_array
+ */
+export function aabb3_from_triangle_by_index(output, output_offset, index, index_array, position_array) {
+    const i3 = index * 3;
+    aabb3_compute_from_triangle(output, output_offset, position_array,
+        index_array[i3],
+        index_array[i3 + 1],
+        index_array[i3 + 2],
+    );
+}

package/src/core/bvh8/build/bvh8_build_for_geometry.d.ts

@@ -0,0 +1,10 @@
+/**
+ *
+ * @param {BVH8} bvh8 output
+ * @param {number[] | Uint32Array | Uint16Array} index_array
+ * @param {number[] | Float32Array | Float64Array} position_array
+ * @param {AABB3} [bounds]
+ */
+export function bvh8_build_for_geometry(bvh8: BVH8, index_array: number[] | Uint32Array | Uint16Array, position_array: number[] | Float32Array | Float64Array, bounds?: AABB3): void;
+import { AABB3 } from "../../geom/3d/aabb/AABB3.js";
+//# sourceMappingURL=bvh8_build_for_geometry.d.ts.map

package/src/core/bvh8/build/bvh8_build_for_geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bvh8_build_for_geometry.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh8/build/bvh8_build_for_geometry.js"],"names":[],"mappings":"AAiBA;;;;;;GAMG;AACH,iEAJW,MAAM,EAAE,GAAG,WAAW,GAAG,WAAW,kBACpC,MAAM,EAAE,GAAG,YAAY,GAAG,YAAY,WACtC,KAAK,QAwRf;sBAzSqB,6BAA6B"}