@woosh/meep-engine 2.34.42 → 2.34.46

package/core/bvh2/aabb3/AABB3.spec.js

@@ -1,11 +1,9 @@
 import { BinaryBuffer } from "../../binary/BinaryBuffer.js";
-import {
-    AABB3,
-    deserializeAABB3,
-    deserializeAABB3Quantized16Uint,
-    serializeAABB3,
-    serializeAABB3Quantized16Uint
-} from "./AABB3.js";
+import { AABB3 } from "./AABB3.js";
+import { serializeAABB3Quantized16Uint } from "./serializeAABB3Quantized16Uint.js";
+import { deserializeAABB3Quantized16Uint } from "./deserializeAABB3Quantized16Uint.js";
+import { serializeAABB3 } from "./serializeAABB3.js";
+import { deserializeAABB3 } from "./deserializeAABB3.js";
 
 
 function compareBounds(expected, actual, numDigits = 10) {

package/core/bvh2/aabb3/aabb3_array_intersects_ray.js

@@ -1,6 +1,6 @@
 //
 
-import { intersectRay } from "./AABB3Math.js";
+import { aabb3_intersects_ray } from "./aabb3_intersects_ray.js";
 
 /**
  *
@@ -13,7 +13,7 @@ import { intersectRay } from "./AABB3Math.js";
  * @param {number} direction_z
  */
 export function aabb3_array_intersects_ray(aabb, origin_x, origin_y, origin_z, direction_x, direction_y, direction_z) {
-    return intersectRay(aabb[0], aabb[1], aabb[2], aabb[3], aabb[4], aabb[5],
+    return aabb3_intersects_ray(aabb[0], aabb[1], aabb[2], aabb[3], aabb[4], aabb[5],
         origin_x, origin_y, origin_z,
         direction_x, direction_y, direction_z
     );

package/core/bvh2/aabb3/aabb3_box_surface_area_2.js

@@ -0,0 +1,10 @@
+import { aabb3_compute_half_surface_area } from "./aabb3_compute_half_surface_area.js";
+
+/**
+ *
+ * @param {AABB3} node
+ * @returns {number}
+ */
+export function aabb3_box_surface_area_2(node) {
+    return aabb3_compute_half_surface_area(node.x0, node.y0, node.z0, node.x1, node.y1, node.z1);
+}

package/core/bvh2/aabb3/aabb3_compute_half_surface_area.js

@@ -0,0 +1,16 @@
+/**
+ *
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @returns {number}
+ */
+export function aabb3_compute_half_surface_area(x0, y0, z0, x1, y1, z1) {
+    const dx = x1 - x0;
+    const dy = y1 - y0;
+    const dz = z1 - z0;
+    return dy * (dx + dz) + dz * dx; //1 side, since it's a heuristic only
+}

package/core/bvh2/aabb3/aabb3_compute_surface_area.js

@@ -0,0 +1,18 @@
+/**
+ *
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @returns {number}
+ */
+function aabb3_compute_surface_area(x0, y0, z0, x1, y1, z1) {
+    const dx = x1 - x0;
+    const dy = y1 - y0;
+    const dz = z1 - z0;
+    return (dy * (dx + dz) + dz * dx) * 2; //2 of each side
+}
+
+export { aabb3_compute_surface_area };

package/core/bvh2/aabb3/aabb3_expand_array.js

@@ -0,0 +1,15 @@
+/**
+ *
+ * @param {ArrayLike<number>|number[]|Float64Array|Float32Array} input
+ * @param {ArrayLike<number>|number[]|Float64Array|Float32Array} output
+ * @param {number} distance
+ */
+export function aabb3_expand_array(input, output, distance) {
+    output[0] = input[0] - distance;
+    output[1] = input[1] - distance;
+    output[2] = input[2] - distance;
+
+    output[3] = input[3] + distance;
+    output[4] = input[4] + distance;
+    output[5] = input[5] + distance;
+}

package/core/bvh2/aabb3/aabb3_intersect_aabb3.js

@@ -0,0 +1,28 @@
+import { intersects1D } from "../../math/intersects1D.js";
+
+/**
+ *
+ * @param {number} ax0
+ * @param {number} ay0
+ * @param {number} az0
+ * @param {number} ax1
+ * @param {number} ay1
+ * @param {number} az1
+ * @param {number} bx0
+ * @param {number} by0
+ * @param {number} bz0
+ * @param {number} bx1
+ * @param {number} by1
+ * @param {number} bz1
+ * @returns {boolean}
+ */
+export function aabb3_intersect_aabb3(
+    ax0, ay0, az0,
+    ax1, ay1, az1,
+    bx0, by0, bz0,
+    bx1, by1, bz1
+) {
+    return intersects1D(ax0, ax1, bx0, bx1)
+        && intersects1D(ay0, ay1, by0, by1)
+        && intersects1D(az0, az1, bz0, bz1);
+}

package/core/bvh2/aabb3/aabb3_intersect_ray_slab.js

@@ -0,0 +1,73 @@
+import { min2 } from "../../math/min2.js";
+import { max2 } from "../../math/max2.js";
+
+/**
+ * see: https://tavianator.com/fast-branchless-raybounding-box-intersections-part-2-nans/
+ * NOTE: this solution forgoes consistent handling of NaNs in favor of execution speed
+ * FIXME some manual tests have shown deviation in results between this implementation and others. Possible bugs?
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @param {number} oX
+ * @param {number} oY
+ * @param {number} oZ
+ * @param {number} dirX
+ * @param {number} dirY
+ * @param {number} dirZ
+ * @returns {boolean}
+ */
+export function aabb3_intersect_ray_slab(
+    x0, y0, z0,
+    x1, y1, z1,
+    oX, oY, oZ,
+    dirX, dirY, dirZ
+) {
+    /*
+    Java CODE:
+        bool intersection(box b, ray r) {
+            double t1 = (b.min[0] - r.origin[0])*r.dir_inv[0];
+            double t2 = (b.max[0] - r.origin[0])*r.dir_inv[0];
+
+            double tmin = min(t1, t2);
+            double tmax = max(t1, t2);
+
+            for (int i = 1; i < 3; ++i) {
+                t1 = (b.min[i] - r.origin[i])*r.dir_inv[i];
+                t2 = (b.max[i] - r.origin[i])*r.dir_inv[i];
+
+                tmin = max(tmin, min(t1, t2));
+                tmax = min(tmax, max(t1, t2));
+            }
+
+            return tmax > max(tmin, 0.0);
+        }
+
+     */
+    const dir_inv_x = -dirX;
+    const dir_inv_y = -dirY;
+    const dir_inv_z = -dirZ;
+
+    const t1_x = (x0 - oX) * dir_inv_x;
+    const t2_x = (x1 - oX) * dir_inv_x;
+
+    const tMin_x = min2(t1_x, t2_x);
+    const tMax_x = max2(t1_x, t2_x);
+
+    const t1_y = (y0 - oY) * dir_inv_y;
+    const t2_y = (y1 - oY) * dir_inv_y;
+
+    const tMin_y = max2(tMin_x, min2(t1_y, t2_y));
+    const tMax_y = min2(tMax_x, max2(t1_y, t2_y));
+
+    const t1_z = (z0 - oZ) * dir_inv_z;
+    const t2_z = (z1 - oZ) * dir_inv_z;
+
+    const tMin_z = max2(tMin_y, min2(t1_z, t2_z));
+    const tMax_z = min2(tMax_y, max2(t1_z, t2_z));
+
+
+    return tMax_z > max2(tMin_z, 0.0);
+}

package/core/bvh2/aabb3/{aabb3_intersects_frustum.js → aabb3_intersects_frustum_array.js}

@@ -6,7 +6,7 @@ import { aabb3_computeDistanceAbovePlane } from "../../geom/3d/aabb/aabb3_comput
  * @param {Float32Array|number[]} frustum
  * @return {boolean}
  */
-export function aabb3_intersects_frustum(aabb, frustum) {
+export function aabb3_intersects_frustum_array(aabb, frustum) {
 
     const x0 = aabb[0];
     const y0 = aabb[1];
@@ -15,6 +15,21 @@ export function aabb3_intersects_frustum(aabb, frustum) {
     const y1 = aabb[4];
     const z1 = aabb[5];
 
+    return aabb3_intersects_frustum(x0, y0, z0, x1, y1, z1, frustum);
+}
+
+/**
+ *
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @param {ArrayLike<number>|number[]|Float32Array|Float64Array} frustum
+ * @return {boolean}
+ */
+export function aabb3_intersects_frustum(x0, y0, z0, x1, y1, z1, frustum) {
     for (let i = 0; i < 24; i += 4) {
 
         const plane_n_x = frustum[i];

package/core/bvh2/aabb3/aabb3_intersects_line_segment.js

@@ -0,0 +1,79 @@
+import { fabsf } from "../../math/fabsf.js";
+
+/**
+ *
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @param {number} startX
+ * @param {number} startY
+ * @param {number} startZ
+ * @param {number} endX
+ * @param {number} endY
+ * @param {number} endZ
+ * @returns {boolean}
+ */
+function aabb3_intersects_line_segment(
+    x0, y0, z0,
+    x1, y1, z1,
+    startX, startY, startZ,
+    endX, endY, endZ
+) {
+
+    let boxExtentsX,
+        boxExtentsY,
+        boxExtentsZ,
+        diffX,
+        diffY,
+        diffZ,
+        dirX,
+        dirY,
+        dirZ,
+        centerX,
+        centerY,
+        centerZ;
+    //
+    let a, b, c;
+
+    dirX = 0.5 * (endX - startX);
+    boxExtentsX = (x1 - x0) / 2;
+    centerX = x0 + boxExtentsX;
+    diffX = (0.5 * (endX + startX)) - centerX;
+    a = fabsf(dirX);
+    if (fabsf(diffX) > boxExtentsX + a) return false;
+    //
+    dirY = 0.5 * (endY - startY);
+    boxExtentsY = (y1 - y0) / 2;
+    centerY = y0 + boxExtentsY;
+    diffY = (0.5 * (endY + startY)) - centerY;
+    b = fabsf(dirY);
+    if (fabsf(diffY) > boxExtentsY + b) return false;
+    //
+    dirZ = 0.5 * (endZ - startZ);
+    boxExtentsZ = (z1 - z0) / 2;
+    centerZ = z0 + boxExtentsZ;
+    diffZ = (0.5 * (endZ + startZ)) - centerZ;
+    c = fabsf(dirZ);
+    if (fabsf(diffZ) > boxExtentsZ + c) return false;
+
+    //Dir.y = 0.5f * (segment.mP1.y - segment.mP0.y);
+    //BoxExtents.y = aabb.GetExtents(1);
+    //Diff.y = (0.5f * (segment.mP1.y + segment.mP0.y)) - aabb.GetCenter(1);
+    //b = fabsf(Dir.y);
+    //if(fabsf(Diff.y)>BoxExtents.y + b)	return false;
+
+    let f;
+    f = dirY * diffZ - dirZ * diffY;
+    if (fabsf(f) > boxExtentsY * c + boxExtentsZ * b) return false;
+    f = dirZ * diffX - dirX * diffZ;
+    if (fabsf(f) > boxExtentsX * c + boxExtentsZ * a) return false;
+    f = dirX * diffY - dirY * diffX;
+    if (fabsf(f) > boxExtentsX * b + boxExtentsY * a) return false;
+
+    return true;
+}
+
+export { aabb3_intersects_line_segment };

package/core/bvh2/aabb3/aabb3_intersects_ray.js

@@ -0,0 +1,92 @@
+import { fabsf } from "../../math/fabsf.js";
+
+/**
+ * NOTES:
+ *      https://web.archive.org/web/20090803054252/http://tog.acm.org/resources/GraphicsGems/gems/RayBox.c
+ *      https://tavianator.com/fast-branchless-raybounding-box-intersections/
+ *      https://gamedev.stackexchange.com/questions/18436/most-efficient-aabb-vs-ray-collision-algorithms
+ *
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @param {number} oX
+ * @param {number} oY
+ * @param {number} oZ
+ * @param {number} dirX
+ * @param {number} dirY
+ * @param {number} dirZ
+ * @returns {boolean}
+ */
+function aabb3_intersects_ray(x0, y0, z0, x1, y1, z1, oX, oY, oZ, dirX, dirY, dirZ) {
+
+    // Z Projection
+    const boxExtentsX = (x1 - x0) / 2;
+
+    const centerX = x0 + boxExtentsX;
+
+    const diffX = oX - centerX;
+
+
+    if (fabsf(diffX) > boxExtentsX && diffX * dirX >= 0.0) {
+        return false;
+    }
+
+    // Y projection
+    const boxExtentsY = (y1 - y0) / 2;
+
+    const centerY = y0 + boxExtentsY;
+
+    const diffY = oY - centerY;
+
+
+    if (fabsf(diffY) > boxExtentsY && diffY * dirY >= 0.0) {
+        return false;
+    }
+
+    // Z projection
+    const boxExtentsZ = (z1 - z0) / 2;
+
+    const centerZ = z0 + boxExtentsZ;
+
+    const diffZ = oZ - centerZ;
+
+
+    if (fabsf(diffZ) > boxExtentsZ && diffZ * dirZ >= 0.0) {
+        return false;
+    }
+
+    //Dir.y = 0.5f * (segment.mP1.y - segment.mP0.y);
+    //BoxExtents.y = aabb.GetExtents(1);
+    //Diff.y = (0.5f * (segment.mP1.y + segment.mP0.y)) - aabb.GetCenter(1);
+    //b = fabsf(Dir.y);
+    //if(fabsf(Diff.y)>BoxExtents.y + b)	return false;
+
+    const a = fabsf(dirX);
+    const b = fabsf(dirY);
+    const c = fabsf(dirZ);
+
+    const f0 = dirY * diffZ - dirZ * diffY;
+
+    if (fabsf(f0) > boxExtentsY * c + boxExtentsZ * b) {
+        return false;
+    }
+
+    const f1 = dirZ * diffX - dirX * diffZ;
+
+    if (fabsf(f1) > boxExtentsX * c + boxExtentsZ * a) {
+        return false;
+    }
+
+    const f2 = dirX * diffY - dirY * diffX;
+
+    if (fabsf(f2) > boxExtentsX * b + boxExtentsY * a) {
+        return false;
+    }
+
+    return true;
+}
+
+export { aabb3_intersects_ray };

package/core/bvh2/aabb3/{AABB3Math.spec.js → aabb3_intersects_ray.spec.js}

@@ -1,5 +1,5 @@
 import { seededRandom } from "../../math/random/seededRandom.js";
-import { intersectRay } from "./AABB3Math.js";
+import { aabb3_intersects_ray } from "./aabb3_intersects_ray.js";
 
 test.skip("performance raycast", () => {
     const rng = seededRandom(42);
@@ -13,7 +13,7 @@ test.skip("performance raycast", () => {
     //warm up
     for (i = 0; i < 10000; i++) {
         rng();
-        intersectRay(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0);
+        aabb3_intersects_ray(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0);
     }
 
     //isolate timing of random function
@@ -57,7 +57,7 @@ test.skip("performance raycast", () => {
         const dirY = rng();
         const dirZ = rng();
 
-        if (intersectRay(x0, y0, z0, x1, y1, z1, oX, oY, oZ, dirX, dirY, dirZ)) {
+        if (aabb3_intersects_ray(x0, y0, z0, x1, y1, z1, oX, oY, oZ, dirX, dirY, dirZ)) {
             p++;
         }
     }

package/core/bvh2/aabb3/aabb3_intersects_ray_fast.js

@@ -0,0 +1,176 @@
+/**
+ * Fast Ray-Box intersection
+ * From "Graphics Gems", Academic Press, 1990
+ * ported from C
+ * see: https://web.archive.org/web/20090803054252/http://tog.acm.org/resources/GraphicsGems/gems/RayBox.c
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @param {number} oX
+ * @param {number} oY
+ * @param {number} oZ
+ * @param {number} dirX
+ * @param {number} dirY
+ * @param {number} dirZ
+ * @returns {boolean}
+ */
+export function aabb3_intersects_ray_fast(x0, y0, z0, x1, y1, z1, oX, oY, oZ, dirX, dirY, dirZ) {
+    let inside = true;
+
+    let quadrantX = 0;
+    let quadrantY = 0;
+    let quadrantZ = 0;
+
+    let maxTX = 0;
+    let maxTY = 0;
+    let maxTZ = 0;
+
+    let maxT = 0;
+
+    let candidatePlaneX = 0;
+    let candidatePlaneY = 0;
+    let candidatePlaneZ = 0;
+
+    let coordX = 0;
+    let coordY = 0;
+    let coordZ = 0;
+
+    /*
+        find candidate planes
+     */
+    if (oX < x0) {
+        quadrantX = 1; //LEFT
+        candidatePlaneX = x0;
+        inside = false;
+    } else if (oX > x1) {
+        quadrantX = 0; //RIGHT
+        candidatePlaneX = x1;
+        inside = false;
+    } else {
+        quadrantX = 2; //MIDDLE
+    }
+
+    if (oY < y0) {
+        quadrantY = 1; //LEFT
+        candidatePlaneY = y0;
+        inside = false;
+    } else if (oY > y1) {
+        quadrantY = 0; //RIGHT
+        candidatePlaneY = y1;
+        inside = false;
+    } else {
+        quadrantY = 2; //MIDDLE
+    }
+
+    if (oZ < z0) {
+        quadrantZ = 1; //LEFT
+        candidatePlaneZ = z0;
+        inside = false;
+    } else if (oZ > z1) {
+        quadrantZ = 0; //RIGHT
+        candidatePlaneZ = z1;
+        inside = false;
+    } else {
+        quadrantZ = 2; //MIDDLE
+    }
+
+    // Ray origin inside the bounding box
+    if (inside) {
+        return true;
+    }
+
+    // Calculate T distances to candidate planes
+    if (quadrantX !== 2 && dirX !== 0) {
+        maxTX = (candidatePlaneX - oX) / dirX;
+    } else {
+        maxTX = -1;
+    }
+
+    if (quadrantY !== 2 && dirY !== 0) {
+        maxTY = (candidatePlaneY - oY) / dirY;
+    } else {
+        maxTY = -1;
+    }
+
+    if (quadrantZ !== 2 && dirZ !== 0) {
+        maxTZ = (candidatePlaneZ - oZ) / dirZ;
+    } else {
+        maxTZ = -1;
+    }
+
+    // Get largest of maxT's for final choice of intersection
+    if (maxTX < maxTY) {
+        if (maxTY < maxTZ) {
+            maxT = maxTZ;
+            // Check if final candidate actually inside the box
+            if (maxT < 0) {
+                return false;
+            }
+
+            coordX = oX + maxT * dirX;
+            if (coordX < x0 || coordX > x1) {
+                return false;
+            }
+
+            coordY = oY + maxT * dirY;
+            if (coordY < y0 || coordY > y1) {
+                return false;
+            }
+
+        } else {
+            maxT = maxTY;
+            // Check if final candidate actually inside the box
+            if (maxT < 0) {
+                return false;
+            }
+
+            coordX = oX + maxT * dirX;
+            if (coordX < x0 || coordX > x1) {
+                return false;
+            }
+
+            coordZ = oZ + maxT * dirZ;
+            if (coordZ < z0 || coordZ > z1) {
+                return false;
+            }
+        }
+    } else if (maxTX < maxTZ) {
+        maxT = maxTZ;
+        // Check if final candidate actually inside the box
+        if (maxT < 0) {
+            return false;
+        }
+
+        coordX = oX + maxT * dirX;
+        if (coordX < x0 || coordX > x1) {
+            return false;
+        }
+
+        coordY = oY + maxT * dirY;
+        if (coordY < y0 || coordY > y1) {
+            return false;
+        }
+    } else {
+        maxT = maxTX;
+        // Check if final candidate actually inside the box
+        if (maxT < 0) {
+            return false;
+        }
+
+        coordY = oY + maxT * dirY;
+        if (coordY < y0 || coordY > y1) {
+            return false;
+        }
+
+        coordZ = oZ + maxT * dirZ;
+        if (coordZ < z0 || coordZ > z1) {
+            return false;
+        }
+    }
+
+    //ray hits the box
+    return true;
+}

package/core/bvh2/aabb3/aabb3_score_boxes_SAH.js

@@ -0,0 +1,43 @@
+import { aabb3_compute_half_surface_area } from "./aabb3_compute_half_surface_area.js";
+
+/**
+ * Compute surface area for a box contain both inputs
+ * @param {AABB3} a
+ * @param {AABB3} b
+ * @returns {number}
+ */
+function aabb3_score_boxes_SAH(a, b) {
+    let x0, y0, z0, x1, y1, z1;
+
+    //
+
+    const ax0 = a.x0;
+    const ay0 = a.y0;
+    const az0 = a.z0;
+    const ax1 = a.x1;
+    const ay1 = a.y1;
+    const az1 = a.z1;
+
+    const bx0 = b.x0;
+    const by0 = b.y0;
+    const bz0 = b.z0;
+    const bx1 = b.x1;
+    const by1 = b.y1;
+    const bz1 = b.z1;
+
+    //
+
+    x0 = ax0 < bx0 ? ax0 : bx0;
+    y0 = ay0 < by0 ? ay0 : by0;
+    z0 = az0 < bz0 ? az0 : bz0;
+
+    x1 = ax1 > bx1 ? ax1 : bx1;
+    y1 = ay1 > by1 ? ay1 : by1;
+    z1 = az1 > bz1 ? az1 : bz1;
+
+    //
+
+    return aabb3_compute_half_surface_area(x0, y0, z0, x1, y1, z1);
+}
+
+export { aabb3_score_boxes_SAH };

package/core/bvh2/aabb3/aabb_score_boxes_SAH_delta.js

@@ -0,0 +1,37 @@
+import { aabb3_compute_half_surface_area } from "./aabb3_compute_half_surface_area.js";
+
+/**
+ *
+ * @param {AABB3} b0
+ * @param {AABB3} b1
+ * @return {number}
+ */
+function aabb3_score_boxes_SAH_delta(b0, b1) {
+    let x0, y0, z0, x1, y1, z1;
+    //
+    const b0x0 = b0.x0;
+    const b0y0 = b0.y0;
+    const b0z0 = b0.z0;
+    const b0x1 = b0.x1;
+    const b0y1 = b0.y1;
+    const b0z1 = b0.z1;
+
+    const b1x0 = b1.x0;
+    const b1y0 = b1.y0;
+    const b1z0 = b1.z0;
+    const b1x1 = b1.x1;
+    const b1y1 = b1.y1;
+    const b1z1 = b1.z1;
+    //
+    x0 = b0x0 < b1x0 ? b0x0 : b1x0;
+    y0 = b0y0 < b1y0 ? b0y0 : b1y0;
+    z0 = b0z0 < b1z0 ? b0z0 : b1z0;
+    x1 = b0x1 > b1x1 ? b0x1 : b1x1;
+    y1 = b0y1 > b1y1 ? b0y1 : b1y1;
+    z1 = b0z1 > b1z1 ? b0z1 : b1z1;
+    //
+    const totalArea = aabb3_compute_half_surface_area(x0, y0, z0, x1, y1, z1);
+    const area0 = b0.getSurfaceArea();
+    const area1 = b1.getSurfaceArea();
+    return totalArea - Math.max(area0, area1);
+}