@woosh/meep-engine 2.48.22 → 2.49.0

package/src/core/geom/2d/aabb/aabb2_signed_distance_sqr_to_point.js

@@ -0,0 +1,45 @@
+import { max2 } from "../../../math/max2.js";
+
+/**
+ * Compute squared distance to point, value is negative if the point is inside the box
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} point_x
+ * @param {number} point_y
+ * @returns {number}
+ */
+export function aabb2_signed_distance_sqr_to_point(
+    x0, y0,
+    x1, y1,
+    point_x, point_y
+) {
+    //do projection
+    const xp0 = x0 - point_x;
+    const xp1 = point_x - x1;
+    const yp0 = y0 - point_y;
+    const yp1 = point_y - y1;
+
+    //calculate separation in each axis
+    let dx = max2(xp0, xp1);
+    let dy = max2(yp0, yp1);
+
+    if (dx >= 0 || dy >= 0) {
+        // non-penetrating, clamp axis
+        dx = max2(dx, 0);
+        dy = max2(dy, 0);
+
+        //straight-line distance
+        return (dx * dx + dy * dy);
+    } else {
+
+        //penetration, negative distance, pick nearest axis
+        if (Math.abs(dx) > Math.abs(dy)) {
+            return -(dy * dy)
+        } else {
+            return -dx * dx;
+        }
+
+    }
+}

package/src/core/geom/2d/aabb/aabb2_signed_distance_sqr_to_point.spec.js

@@ -0,0 +1,40 @@
+import { aabb2_signed_distance_sqr_to_point } from "./aabb2_signed_distance_sqr_to_point.js";
+
+test("0 size bounding box", () => {
+
+    expect(aabb2_signed_distance_sqr_to_point(0, 0, 0, 0, 0, 0))
+        .toEqual(0);
+
+    expect(aabb2_signed_distance_sqr_to_point(0, 0, 0, 0, 1, 0))
+        .toEqual(1);
+
+    expect(aabb2_signed_distance_sqr_to_point(0, 0, 0, 0, -1, 0))
+        .toEqual(1);
+
+    expect(aabb2_signed_distance_sqr_to_point(0, 0, 0, 0, 0, 1))
+        .toEqual(1);
+
+    expect(aabb2_signed_distance_sqr_to_point(0, 0, 0, 0, 0, -1))
+        .toEqual(1);
+
+    expect(aabb2_signed_distance_sqr_to_point(0, 0, 0, 0, 1, 1))
+        .toEqual(2);
+
+    expect(aabb2_signed_distance_sqr_to_point(0, 0, 0, 0, 1, -1))
+        .toEqual(2);
+
+    expect(aabb2_signed_distance_sqr_to_point(0, 0, 0, 0, -1, 1))
+        .toEqual(2);
+
+    expect(aabb2_signed_distance_sqr_to_point(0, 0, 0, 0, -1, -1))
+        .toEqual(2);
+
+});
+
+
+test("inside the box", () => {
+
+    expect(aabb2_signed_distance_sqr_to_point(-1, -1, 1, 1, 0, 0))
+        .toBeCloseTo(-1);
+
+});

package/src/core/geom/2d/aabb/aabb2_signed_distance_to_point.js

@@ -0,0 +1,27 @@
+//
+
+import { aabb2_signed_distance_sqr_to_point } from "./aabb2_signed_distance_sqr_to_point.js";
+
+/**
+ * Compute squared distance to point, value is negative if the point is inside the box
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} point_x
+ * @param {number} point_y
+ * @returns {number}
+ */
+export function aabb2_signed_distance_to_point(
+    x0, y0,
+    x1, y1,
+    point_x, point_y
+) {
+    const sqr = aabb2_signed_distance_sqr_to_point(x0, y0, x1, y1, point_x, point_y);
+
+    if (sqr < 0) {
+        return -Math.sqrt(-sqr);
+    } else {
+        return Math.sqrt(sqr);
+    }
+}

package/src/core/geom/2d/convex-hull/fixed_convex_hull_humus.js

@@ -41,6 +41,10 @@ export function fixed_convex_hull_humus(
 
     const ArrayConstructor = UintArrayForCount(k);
 
+    /**
+     *
+     * @type {number[]}
+     */
     const s = new ArrayConstructor(k);
 
     let combos = 0;

package/src/core/geom/2d/quad-tree/PointQuadTree.js

@@ -71,6 +71,9 @@ Element.prototype.remove = function () {
     this.parentNode.removeElement(this);
 };
 
+/**
+ * Prefer to use {@link QuadTreeNode} instead as that is more robust and has better performance
+ */
 class PointQuadTree {
     /**
      * @param {number} [x0]

package/src/core/geom/2d/quad-tree/QuadTreeDatum.js

@@ -1,5 +1,5 @@
 import { assert } from "../../../assert.js";
-import AABB2 from "../../AABB2.js";
+import AABB2 from "../../2d/aabb/AABB2.js";
 
 /**
  * @template D

package/src/core/geom/2d/quad-tree/QuadTreeNode.js

@@ -1,7 +1,7 @@
 import { assert } from "../../../assert.js";
 import { max2 } from "../../../math/max2.js";
 import { min2 } from "../../../math/min2.js";
-import AABB2 from "../../AABB2.js";
+import AABB2 from "../../2d/aabb/AABB2.js";
 import { QuadTreeDatum } from "./QuadTreeDatum.js";
 
 
@@ -241,8 +241,8 @@ export class QuadTreeNode extends AABB2 {
         const x1 = this.x1;
         const y1 = this.y1;
 
-        const xm = (x0 + x1) / 2;
-        const ym = (y0 + y1) / 2;
+        const xm = (x0 + x1) * 0.5;
+        const ym = (y0 + y1) * 0.5;
 
         this.topLeft = new QuadTreeNode(x0, y0, xm, ym);
         this.topLeft.parentNode = this;

package/src/core/geom/2d/quad-tree/qt_collect_by_circle.js

@@ -1,4 +1,4 @@
-import { aabb2_sqrDistanceToPoint } from "../AABB2Math.js";
+import { aabb2_distance_sqr_to_point } from "../aabb/aabb2_distance_sqr_to_point.js";
 
 /**
  *
@@ -23,19 +23,17 @@ export function qt_collect_by_circle(
 ) {
     let result_cursor = result_offset;
 
-    let stack_pointer = 0;
+    let stack_pointer = 1;
 
     const r2 = radius * radius;
 
-    node_stack[stack_pointer] = tree;
-    stack_pointer++;
+    node_stack[0] = tree;
 
-    while (stack_pointer > 0) {
+    while (stack_pointer-- > 0) {
 
-        --stack_pointer;
         const node = node_stack[stack_pointer];
 
-        const d2 = aabb2_sqrDistanceToPoint(node.x0, node.y0, node.x1, node.y1, x, y);
+        const d2 = aabb2_distance_sqr_to_point(node.x0, node.y0, node.x1, node.y1, x, y);
 
         if (d2 > r2) {
             // not a match
@@ -48,7 +46,7 @@ export function qt_collect_by_circle(
         for (let i = 0; i < data_count; i++) {
             const datum = data[i];
 
-            const d2_to_datum = aabb2_sqrDistanceToPoint(datum.x0, datum.y0, datum.x1, datum.y1, x, y);
+            const d2_to_datum = aabb2_distance_sqr_to_point(datum.x0, datum.y0, datum.x1, datum.y1, x, y);
 
             if (d2_to_datum <= r2) {
                 result[result_cursor++] = datum;

package/src/core/geom/2d/quad-tree/qt_match_data_by_circle.js

@@ -1,4 +1,4 @@
-import { aabb2_sqrDistanceToPoint } from "../AABB2Math.js";
+import { aabb2_distance_sqr_to_point } from "../aabb/aabb2_distance_sqr_to_point.js";
 
 /**
  *
@@ -38,7 +38,7 @@ export function qt_match_data_by_circle(
         --stack_pointer;
         const node = node_stack[stack_pointer];
 
-        const d2 = aabb2_sqrDistanceToPoint(node.x0, node.y0, node.x1, node.y1, x, y);
+        const d2 = aabb2_distance_sqr_to_point(node.x0, node.y0, node.x1, node.y1, x, y);
 
         if (d2 > r2) {
             // not a match
@@ -51,7 +51,7 @@ export function qt_match_data_by_circle(
         for (let i = 0; i < data_count; i++) {
             const datum = data[i];
 
-            const d2_to_datum = aabb2_sqrDistanceToPoint(datum.x0, datum.y0, datum.x1, datum.y1, x, y);
+            const d2_to_datum = aabb2_distance_sqr_to_point(datum.x0, datum.y0, datum.x1, datum.y1, x, y);
 
             if (d2_to_datum <= r2 && predicate.call(predicateContext, datum.data)) {
                 result[result_cursor++] = datum;

package/src/core/geom/2d/quad-tree/qt_query_data_nearest_to_point.js

@@ -1,5 +1,4 @@
-import { aabb2_sqrDistanceToPoint } from "../AABB2Math.js";
-import { max2 } from "../../../math/max2.js";
+import { aabb2_distance_sqr_to_point } from "../aabb/aabb2_distance_sqr_to_point.js";
 
 /**
  *
@@ -17,20 +16,18 @@ const node_stack = [];
  */
 export function qt_query_data_nearest_to_point(tree, x, y, max_distance = Infinity) {
 
-    let stack_pointer = 0;
+    let stack_pointer = 1;
 
-    node_stack[stack_pointer] = tree;
-    stack_pointer++;
+    node_stack[0] = tree;
 
     let best_leaf_data = undefined;
     let best_distance_sqr = max_distance * max_distance;
 
-    while (stack_pointer > 0) {
+    while (stack_pointer-- > 0) {
 
-        --stack_pointer;
         const node = node_stack[stack_pointer];
 
-        const distance_sqr = max2(0, aabb2_sqrDistanceToPoint(node.x0, node.y0, node.x1, node.y1, x, y));
+        const distance_sqr = aabb2_distance_sqr_to_point(node.x0, node.y0, node.x1, node.y1, x, y);
 
         if (distance_sqr >= best_distance_sqr) {
             // too far
@@ -38,11 +35,12 @@ export function qt_query_data_nearest_to_point(tree, x, y, max_distance = Infini
         }
 
         const data = node.data;
+        const data_count = data.length;
 
-        for (let i = 0; i < data.length; i++) {
+        for (let i = 0; i < data_count; i++) {
             const datum = data[i];
 
-            const distance_sqr = max2(0, aabb2_sqrDistanceToPoint(datum.x0, datum.y0, datum.x1, datum.y1, x, y));
+            const distance_sqr = aabb2_distance_sqr_to_point(datum.x0, datum.y0, datum.x1, datum.y1, x, y);
 
             if (distance_sqr < best_distance_sqr) {
                 best_leaf_data = datum;

package/src/core/{bvh2/aabb3 → geom/3d/aabb}/AABB3.d.ts

@@ -1,4 +1,4 @@
-import Vector3 from "../../geom/Vector3";
+import Vector3 from "../../Vector3";
 
 export class AABB3 {
     x0: number

package/src/core/{bvh2/aabb3 → geom/3d/aabb}/AABB3.js

@@ -3,19 +3,19 @@
  */
 
 
-import { aabb3_compute_distance_above_plane_max } from "../../geom/3d/aabb/aabb3_compute_distance_above_plane_max.js";
-import { aabb3_compute_plane_side } from "../../geom/3d/aabb/aabb3_compute_plane_side.js";
-import computeMortonCode from "../../geom/3d/morton/Morton.js";
-import { aabb3_build_corners } from "../../geom/3d/aabb/aabb3_build_corners.js";
-import { assert } from "../../assert.js";
-import { aabb3_intersects_frustum_degree } from "../../geom/3d/aabb/aabb3_intersects_frustum_degree.js";
-import { aabb3_intersects_line_segment } from "../../geom/3d/aabb/aabb3_intersects_line_segment.js";
-import { aabb3_intersects_ray } from "../../geom/3d/aabb/aabb3_intersects_ray.js";
-import { aabb3_compute_surface_area } from "../../geom/3d/aabb/aabb3_compute_surface_area.js";
-import { aabb3_intersects_frustum_array } from "../../geom/3d/aabb/aabb3_intersects_frustum_array.js";
-import { aabb3_matrix4_project } from "../../geom/3d/aabb/aabb3_matrix4_project.js";
-import { aabb3_signed_distance_sqr_to_point } from "../../geom/3d/aabb/aabb3_signed_distance_sqr_to_point.js";
-import { aabb3_array_contains_point } from "../../geom/3d/aabb/aabb3_array_contains_point.js";
+import { aabb3_compute_distance_above_plane_max } from "./aabb3_compute_distance_above_plane_max.js";
+import { aabb3_compute_plane_side } from "./aabb3_compute_plane_side.js";
+import computeMortonCode from "../morton/Morton.js";
+import { aabb3_build_corners } from "./aabb3_build_corners.js";
+import { assert } from "../../../assert.js";
+import { aabb3_intersects_frustum_degree } from "./aabb3_intersects_frustum_degree.js";
+import { aabb3_intersects_line_segment } from "./aabb3_intersects_line_segment.js";
+import { aabb3_intersects_ray } from "./aabb3_intersects_ray.js";
+import { aabb3_compute_surface_area } from "./aabb3_compute_surface_area.js";
+import { aabb3_intersects_frustum_array } from "./aabb3_intersects_frustum_array.js";
+import { aabb3_matrix4_project } from "./aabb3_matrix4_project.js";
+import { aabb3_signed_distance_sqr_to_point } from "./aabb3_signed_distance_sqr_to_point.js";
+import { aabb3_array_contains_point } from "./aabb3_array_contains_point.js";
 
 
 export class AABB3 {

package/src/core/{bvh2/aabb3 → geom/3d/aabb}/AABB3.spec.js

@@ -1,4 +1,4 @@
-import { BinaryBuffer } from "../../binary/BinaryBuffer.js";
+import { BinaryBuffer } from "../../../binary/BinaryBuffer.js";
 import { AABB3 } from "./AABB3.js";
 import { serializeAABB3Quantized16Uint } from "./serializeAABB3Quantized16Uint.js";
 import { deserializeAABB3Quantized16Uint } from "./deserializeAABB3Quantized16Uint.js";

package/src/core/geom/3d/aabb/aabb3_compute_plane_side.js

@@ -1,4 +1,4 @@
-import { v3_distance_above_plane } from "../../v3_distance_above_plane.js";
+import { v3_dot } from "../../v3_dot.js";
 
 /**
  * 2,0,or -2; 2: above, -2 : below, 0 : intersects plane
@@ -26,7 +26,6 @@ export function aabb3_compute_plane_side(
     _y1,
     _z1
 ) {
-    let result = 0;
 
     let x0,
         y0,
@@ -60,23 +59,26 @@ export function aabb3_compute_plane_side(
         z1 = _z0;
     }
 
-    // check the nearest corner
+    /*
+      planar tests are inlined for performance and to save on a few operation,
+      if you write it out fully it would be vec4 dot product and comparison to 0,
+      since we don't have 4th component for AABB corners,
+      we can use vec3 and just move planar offset to the right-hand side of the comparison operation
+     */
 
-    if (v3_distance_above_plane(x0, y0, z0, plane_normal_x, plane_normal_y, plane_normal_z, plane_constant) >= 0) {
-        // above the plane
-        result += 1;
-    } else {
-        result -= 1;
-    }
+    const neg_plane_constant = -plane_constant;
 
     // check the farthest corner
+    if (v3_dot(x1, y1, z1, plane_normal_x, plane_normal_y, plane_normal_z) < neg_plane_constant) {
+        // if furthest corner is below plane, the nearest one will be as well, no need to continue
+        return -2;
+    }
 
-    if (v3_distance_above_plane(x1, y1, z1, plane_normal_x, plane_normal_y, plane_normal_z, plane_constant) >= 0) {
-        // above the plane
-        result += 1;
-    } else {
-        result -= 1;
+    // check the nearest corner
+    if (v3_dot(plane_normal_x, plane_normal_y, plane_normal_z, x0, y0, z0) >= neg_plane_constant) {
+        // above the plane, both corners are above the plane
+        return 2;
     }
 
-    return result;
+    return 0;
 }

package/src/core/geom/3d/aabb/aabb3_compute_plane_side.spec.js

@@ -0,0 +1,25 @@
+import { aabb3_compute_plane_side } from "./aabb3_compute_plane_side.js";
+
+test("fully above plane", () => {
+    expect(aabb3_compute_plane_side(
+        0, 1, 0, 0,
+        -1, 0.1, -1,
+        1, 1, 1
+    )).toBe(2);
+});
+
+test("fully below plane", () => {
+    expect(aabb3_compute_plane_side(
+        0, 1, 0, 0,
+        -1, -1, -1,
+        1, -0.1, 1
+    )).toBe(-2);
+});
+
+test("intersects plane", () => {
+    expect(aabb3_compute_plane_side(
+        0, 1, 0, 0,
+        -1, -1, -1,
+        1, 1, 1
+    )).toBe(0);
+});

package/src/core/geom/3d/aabb/aabb3_detailed_volume_intersection.js

@@ -1,12 +1,12 @@
 import { aabb3_build_corners } from "./aabb3_build_corners.js";
 import { aabb_build_frustum } from "./aabb3_build_frustum.js";
-import { plane3_computeLineSegmentIntersection } from "../../Plane.js";
 import { aabb3_corner_edge_mapping } from "./aabb3_corner_edge_mapping.js";
 import { aabb3_edge_corner_mapping } from "./aabb3_edge_corner_mapping.js";
 import { plane_computeConvex3PlaneIntersection } from "../plane/plane_computeConvex3PlaneIntersection.js";
 import { is_point_within_planes } from "../plane/is_point_within_planes.js";
 import { v3_distance_above_plane } from "../../v3_distance_above_plane.js";
 import { EPSILON } from "../../../math/EPSILON.js";
+import { plane3_computeLineSegmentIntersection } from "../plane/plane3_computeLineSegmentIntersection.js";
 
 /**
  * Common piece of continuous memory for better cache coherence

package/src/core/geom/3d/aabb/aabb3_from_v3_array.js

@@ -1,5 +1,6 @@
 import { min2 } from "../../../math/min2.js";
 import { max2 } from "../../../math/max2.js";
+import { assert } from "../../../assert.js";
 
 /**
  *
@@ -8,6 +9,8 @@ import { max2 } from "../../../math/max2.js";
  * @param {number} input_length length of the input array
  */
 export function aabb3_from_v3_array(result, input, input_length) {
+    assert.equal(input_length % 3, 0, `Input must be divisible by 3, instead was ${input_length}`)
+
     let x0 = Infinity;
     let y0 = Infinity;
     let z0 = Infinity;

package/src/core/geom/3d/aabb/aabb3_from_v3_array.spec.js

@@ -0,0 +1,32 @@
+import { aabb3_from_v3_array } from "./aabb3_from_v3_array.js";
+import { AABB3 } from "./AABB3.js";
+
+test("empty list", () => {
+    const box = new AABB3();
+
+    aabb3_from_v3_array(box, [], 0);
+
+    expect(box.x0).toEqual(Infinity);
+    expect(box.x1).toEqual(-Infinity);
+
+    expect(box.y0).toEqual(Infinity);
+    expect(box.y1).toEqual(-Infinity);
+
+    expect(box.z0).toEqual(Infinity);
+    expect(box.z1).toEqual(-Infinity);
+});
+
+test("1 point", () => {
+    const box = new AABB3();
+
+    aabb3_from_v3_array(box, [1, 3, -5], 3);
+
+    expect(box.x0).toEqual(1);
+    expect(box.x1).toEqual(1);
+
+    expect(box.y0).toEqual(3);
+    expect(box.y1).toEqual(3);
+
+    expect(box.z0).toEqual(-5);
+    expect(box.z1).toEqual(-5);
+});

package/src/core/geom/3d/aabb/aabb3_intersects_aabb3.spec.js

@@ -0,0 +1,115 @@
+import { aabb3_intersects_aabb3 } from "./aabb3_intersects_aabb3.js";
+
+test("full containment", () => {
+
+    expect(aabb3_intersects_aabb3(
+        0, 0, 0, 3, 3, 3,
+        1, 1, 1, 2, 2, 2
+    )).toBe(true);
+
+    expect(aabb3_intersects_aabb3(
+        -3, -3, -3, 0, 0, 0,
+        -2, -2, -2, -1, -1, -1
+    )).toBe(true);
+
+});
+
+test("complete separation", () => {
+
+    // X
+    expect(aabb3_intersects_aabb3(
+        -1, -1, -1, 1, 1, 1,
+        2, 1, 1, 3, 2, 2
+    )).toBe(false);
+
+    expect(aabb3_intersects_aabb3(
+        -1, -1, -1, 1, 1, 1,
+        -3, 1, 1, -2, 2, 2
+    )).toBe(false);
+
+    // Y
+    expect(aabb3_intersects_aabb3(
+        -1, -1, -1, 1, 1, 1,
+        1, 2, 1, 2, 3, 2
+    )).toBe(false);
+
+    expect(aabb3_intersects_aabb3(
+        -1, -1, -1, 1, 1, 1,
+        1, -3, 1, 2, -2, 2
+    )).toBe(false);
+
+    // Z
+    expect(aabb3_intersects_aabb3(
+        -1, -1, -1, 1, 1, 1,
+        1, 1, 2, 2, 2, 3
+    )).toBe(false);
+
+    expect(aabb3_intersects_aabb3(
+        -1, -1, -1, 1, 1, 1,
+        1, 1, -3, 2, 2, -2
+    )).toBe(false);
+
+    // XY
+    expect(aabb3_intersects_aabb3(
+        -1, -1, -1, 1, 1, 1,
+        2, 2, 1, 3, 3, 2
+    )).toBe(false);
+
+    expect(aabb3_intersects_aabb3(
+        -1, -1, -1, 1, 1, 1,
+        -3, 2, 1, -2, 3, 2
+    )).toBe(false);
+
+    expect(aabb3_intersects_aabb3(
+        -1, -1, -1, 1, 1, 1,
+        2, -3, 1, 3, -2, 2
+    )).toBe(false);
+
+    expect(aabb3_intersects_aabb3(
+        -1, -1, -1, 1, 1, 1,
+        -3, -3, 1, -2, -2, 2
+    )).toBe(false);
+
+    // YZ
+    expect(aabb3_intersects_aabb3(
+        -1, -1, -1, 1, 1, 1,
+        1, 2, 2, 2, 3, 3
+    )).toBe(false);
+
+    expect(aabb3_intersects_aabb3(
+        -1, -1, -1, 1, 1, 1,
+        1, -3, 2, 2, -2, 3
+    )).toBe(false);
+
+    expect(aabb3_intersects_aabb3(
+        -1, -1, -1, 1, 1, 1,
+        1, 2, -3, 2, 3, 2
+    )).toBe(false);
+
+    expect(aabb3_intersects_aabb3(
+        -1, -1, -1, 1, 1, 1,
+        1, -3, -3, 2, -2, 2
+    )).toBe(false);
+
+    // ZX
+    expect(aabb3_intersects_aabb3(
+        -1, -1, -1, 1, 1, 1,
+        2, 2, 1, 3, 3, 2
+    )).toBe(false);
+
+    expect(aabb3_intersects_aabb3(
+        -1, -1, -1, 1, 1, 1,
+        2, -3, 2, 3, -2, 2
+    )).toBe(false);
+
+    expect(aabb3_intersects_aabb3(
+        -1, -1, -1, 1, 1, 1,
+        -3, 2, 1, -2, 3, 2
+    )).toBe(false);
+
+    expect(aabb3_intersects_aabb3(
+        -1, -1, -1, 1, 1, 1,
+        -3, -3, 2, -2, -2, 2
+    )).toBe(false);
+
+});

package/src/core/geom/3d/aabb/aabb3_raycast.js

@@ -27,7 +27,12 @@ import { max2 } from "../../../math/max2.js";
  * @see https://gdbooks.gitbooks.io/3dcollisions/content/Chapter3/raycast_aabb.html
  * @see https://blog.johnnovak.net/2016/10/22/the-nim-ray-tracer-project-part-4-calculating-box-normals/
  */
-export function aabb3_raycast(result, result_offset, x0, y0, z0, x1, y1, z1, origin_x, origin_y, origin_z, direction_x, direction_y, direction_z) {
+export function aabb3_raycast(
+    result, result_offset,
+    x0, y0, z0, x1, y1, z1,
+    origin_x, origin_y, origin_z,
+    direction_x, direction_y, direction_z
+) {
 
     // first find intersection
     const dir_inv_x = 1 / direction_x;

package/src/core/geom/3d/aabb/aabb3_signed_distance_sqr_to_point.js

@@ -23,17 +23,21 @@ export function aabb3_signed_distance_sqr_to_point(x0, y0, z0, x1, y1, z1, point
     const zp1 = point_z - z1;
 
     //calculate separation in each axis
-    const dx = max2(xp0, xp1);
-    const dy = max2(yp0, yp1);
-    const dz = max2(zp0, zp1);
+    let dx = max2(xp0, xp1);
+    let dy = max2(yp0, yp1);
+    let dz = max2(zp0, zp1);
 
-    //straight-line distance
-    const distance_sqr = dx * dx + dy * dy + dz * dz;
 
-    if (dx < 0 && dy < 0 && dz < 0) {
-        //penetration, negative distance
-        return -distance_sqr;
+    if (dx > 0 || dy > 0 || dz > 0) {
+        // non-penetrating, clamp axis
+        dx = max2(dx, 0);
+        dy = max2(dy, 0);
+        dz = max2(dz, 0);
+
+        //straight-line distance
+        return dx * dx + dy * dy + dz * dz;
     } else {
-        return distance_sqr;
+        //penetration, negative distance
+        return -(dx * dx + dy * dy + dz * dz);
     }
 }

package/src/core/{bvh2/aabb3 → geom/3d/aabb}/serializeAABB3Encoded_v0.js

@@ -44,32 +44,32 @@ export function serializeAABB3Encoded_v0(buffer, box, x0, y0, z0, x1, y1, z1) {
     const zD = z1 - z0;
 
     if ((header & 1) === 0) {
-        const _x0 = (((box.x0 - x0) / xD) * 65535) | 0;
+        const _x0 = Math.floor(((box.x0 - x0) / xD) * 65535);
         buffer.writeUint16(_x0);
     }
 
     if ((header & 2) === 0) {
-        const _x1 = (((box.x1 - x0) / xD) * 65535) | 0;
+        const _x1 = Math.ceil(((box.x1 - x0) / xD) * 65535);
         buffer.writeUint16(_x1);
     }
 
     if ((header & 4) === 0) {
-        const _y0 = (((box.y0 - y0) / yD) * 65535) | 0;
+        const _y0 = Math.floor(((box.y0 - y0) / yD) * 65535);
         buffer.writeUint16(_y0);
     }
 
     if ((header & 8) === 0) {
-        const _y1 = (((box.y1 - y0) / yD) * 65535) | 0;
+        const _y1 = Math.ceil(((box.y1 - y0) / yD) * 65535);
         buffer.writeUint16(_y1);
     }
 
     if ((header & 16) === 0) {
-        const _z0 = (((box.z0 - z0) / zD) * 65535) | 0;
+        const _z0 = Math.floor(((box.z0 - z0) / zD) * 65535);
         buffer.writeUint16(_z0);
     }
 
     if ((header & 32) === 0) {
-        const _z1 = (((box.z1 - z0) / zD) * 65535) | 0;
+        const _z1 = Math.ceil(((box.z1 - z0) / zD) * 65535);
         buffer.writeUint16(_z1);
     }
 }