@woosh/meep-engine 2.39.36 → 2.39.39

package/LICENSE

@@ -0,0 +1,13 @@
+Please note that this package comes without a license.
+No permission is granted for any kind of usage.
+All rights are reserved by the author.
+
+For illustration purposes, this means that unless you have obtained a license, all of the following terms apply:
+    * You are NOT permitted to make copies of this package
+    * You are NOT permitted to re-distribute this package
+    * You are NOT permitted to extend the code from this package
+    * You are NOT permitted to make use of this package for any purpose, commercial or otherwise
+
+If you would like to use this package in any context, please contact me via email so we can arrange a license:
+
+travnick [at] gmail [d0t] com

package/core/assert.js

@@ -280,18 +280,27 @@ assert.isFunction = function (value, name = 'value') {
  * @param {number|*} value
  * @param {string} [name]
  */
-assert.isNonNegativeInteger = function (value, name = 'value') {
+assert.isInteger = function (value, name = 'value') {
     assert.isNumber(value, name);
 
-    if (value < 0) {
-        throw new Error(`${name} must be >= 0, instead was ${value}`);
-    }
-
     if (!Number.isInteger(value)) {
         throw new Error(`${name} must be an integer, instead was ${value}`);
     }
 }
 
+/**
+ *
+ * @param {number|*} value
+ * @param {string} [name]
+ */
+assert.isNonNegativeInteger = function (value, name = 'value') {
+    assert.isInteger(value, name);
+
+    if (value < 0) {
+        throw new Error(`${name} must be >= 0, instead was ${value}`);
+    }
+}
+
 /**
  * @template T
  * @param {T[]} value

package/core/binary/Base64.js

@@ -3,13 +3,21 @@
  * @author Jameson Little
  */
 
-var lookup = [];
-var revLookup = [];
-var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array;
+/**
+ *
+ * @type {string[]}
+ */
+const lookup = [];
+/**
+ *
+ * @type {number[]}
+ */
+const revLookup = [];
+const Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array;
 
-var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+const code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
 
-for (var i = 0, len = code.length; i < len; ++i) {
+for (let i = 0, len = code.length; i < len; ++i) {
     lookup[i] = code[i];
     revLookup[code.charCodeAt(i)] = i;
 }
@@ -19,6 +27,11 @@ for (var i = 0, len = code.length; i < len; ++i) {
 revLookup['-'.charCodeAt(0)] = 62;
 revLookup['_'.charCodeAt(0)] = 63;
 
+/**
+ *
+ * @param {string} b64
+ * @return {number[]}
+ */
 function getLens(b64) {
     var len = b64.length;
 
@@ -41,12 +54,6 @@ function getLens(b64) {
 }
 
 // base64 is 4/3 + up to two characters of the original data
-function byteLength(b64) {
-    var lens = getLens(b64);
-    var validLen = lens[0];
-    var placeHoldersLen = lens[1];
-    return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen;
-}
 
 function _byteLength(b64, validLen, placeHoldersLen) {
     return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen;
@@ -99,37 +106,57 @@ function toByteArray(b64) {
 }
 
 function tripletToBase64(num) {
-    return lookup[num >> 18 & 0x3F] +
-        lookup[num >> 12 & 0x3F] +
-        lookup[num >> 6 & 0x3F] +
-        lookup[num & 0x3F];
+    return lookup[num >> 18 & 0x3F]
+        + lookup[num >> 12 & 0x3F]
+        + lookup[num >> 6 & 0x3F]
+        + lookup[num & 0x3F]
+        ;
 }
 
+/**
+ *
+ * @param {Uint8Array} uint8
+ * @param {number} start
+ * @param {number} end
+ * @return {string}
+ */
 function encodeChunk(uint8, start, end) {
-    var tmp;
-    var output = [];
-    for (var i = start; i < end; i += 3) {
-        tmp =
-            ((uint8[i] << 16) & 0xFF0000) +
-            ((uint8[i + 1] << 8) & 0xFF00) +
-            (uint8[i + 2] & 0xFF);
+    const output = [];
+
+    for (let i = start; i < end; i += 3) {
+
+        const tmp = ((uint8[i] << 16) & 0xFF0000)
+            + ((uint8[i + 1] << 8) & 0xFF00)
+            + (uint8[i + 2] & 0xFF);
+
         output.push(tripletToBase64(tmp));
     }
+
     return output.join('');
 }
 
+/**
+ *
+ * @param {Uint8Array} uint8
+ * @return {string}
+ */
 function fromByteArray(uint8) {
-    var tmp;
-    var len = uint8.length;
-    var extraBytes = len % 3; // if we have 1 byte left, pad 2 bytes
-    var parts = [];
-    var maxChunkLength = 16383; // must be multiple of 3
+    let tmp;
+
+    const len = uint8.length;
+    const extraBytes = len % 3; // if we have 1 byte left, pad 2 bytes
+    const parts = [];
+    const maxChunkLength = 16383; // must be multiple of 3
 
     // go through the array every three bytes, we'll deal with trailing stuff later
-    for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
-        parts.push(encodeChunk(
-            uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)
-        ));
+    const len2 = len - extraBytes;
+
+    for (let i = 0; i < len2; i += maxChunkLength) {
+        const end = (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength);
+
+        const chunk = encodeChunk(uint8, i, end);
+
+        parts.push(chunk);
     }
 
     // pad the end with zeros, but make sure to not forget the extra bytes

package/core/binary/Base64.spec.js

@@ -0,0 +1,14 @@
+import { Base64 } from "./Base64.js";
+
+test("to/from consistency", () => {
+    const source = new Uint8Array(256);
+    for (let i = 0; i < source.length; i++) {
+        source[i] = i;
+    }
+
+    const encoded = Base64.encode(source.buffer);
+
+    const decoded = Base64.decode(encoded);
+
+    expect(Array.from(new Uint8Array(decoded))).toEqual(Array.from(source));
+});

package/core/bvh2/aabb3/AABB3.js

@@ -3,7 +3,7 @@
  */
 
 
-import { aabb3_computeDistanceAbovePlane } from "../../geom/3d/aabb/aabb3_computeDistanceAbovePlane.js";
+import { aabb3_computeDistanceAbovePlane_max } from "../../geom/3d/aabb/aabb3_compute_distance_above_plane_max.js";
 import { computeAABB3PlaneSide } from "../../geom/3d/aabb/computeAABB3PlaneSide.js";
 import computeMortonCode from "../../geom/3d/morton/Morton.js";
 import { aabb3_build_corners } from "../../geom/3d/aabb/aabb3_build_corners.js";
@@ -795,7 +795,7 @@ export class AABB3 {
      * @returns {number}
      */
     computeDistanceAbovePlane(normal_x, normal_y, normal_z, offset) {
-        return aabb3_computeDistanceAbovePlane(
+        return aabb3_computeDistanceAbovePlane_max(
             normal_x, normal_y, normal_z, offset,
             this.x0, this.y0, this.z0,
             this.x1, this.y1, this.z1

package/core/bvh2/aabb3/aabb3_detailed_volume_intersection.js

@@ -1,11 +1,12 @@
 import { aabb3_build_corners } from "../../geom/3d/aabb/aabb3_build_corners.js";
 import { aabb_build_frustum } from "../../geom/3d/aabb/aabb3_build_frustum.js";
-import { computePointDistanceToPlane, plane3_computeLineSegmentIntersection } from "../../geom/Plane.js";
+import { plane3_computeLineSegmentIntersection } from "../../geom/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 "../../geom/3d/plane/plane_computeConvex3PlaneIntersection.js";
 import { EPSILON } from "../../math/MathUtils.js";
 import { is_point_within_planes } from "../../geom/3d/plane/is_point_within_planes.js";
+import { v3_distance_above_plane } from "../../geom/v3_distance_above_plane.js";
 
 /**
  * Common piece of continuous memory for better cache coherence
@@ -120,7 +121,7 @@ export function aabb3_detailed_volume_intersection(
             const nz = planes[plane_address + 2];
             const c = planes[plane_address + 3];
 
-            const distance_to_plane = computePointDistanceToPlane(
+            const distance_to_plane = v3_distance_above_plane(
                 x, y, z,
                 nx, ny, nz, c
             );

package/core/bvh2/aabb3/aabb3_intersects_frustum_array.js

@@ -1,4 +1,4 @@
-import { aabb3_computeDistanceAbovePlane } from "../../geom/3d/aabb/aabb3_computeDistanceAbovePlane.js";
+import { aabb3_computeDistanceAbovePlane_max } from "../../geom/3d/aabb/aabb3_compute_distance_above_plane_max.js";
 
 /**
  *
@@ -19,7 +19,7 @@ export function aabb3_intersects_frustum_array(x0, y0, z0, x1, y1, z1, frustum)
         const plane_z = frustum[i + 2];
         const plane_w = frustum[i + 3];
 
-        const plane_distance = aabb3_computeDistanceAbovePlane(
+        const plane_distance = aabb3_computeDistanceAbovePlane_max(
             plane_x, plane_y, plane_z, plane_w,
             x0, y0, z0,
             x1, y1, z1

package/core/bvh2/bvh3/ExplicitBinaryBoundingVolumeHierarchy.js

@@ -299,6 +299,13 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
     node_set_aabb(id, aabb) {
         assert.isNonNegativeInteger(id, 'id');
 
+        assert.notNaN(aabb[0], 'aabb[0] x0');
+        assert.notNaN(aabb[1], 'aabb[1] y0');
+        assert.notNaN(aabb[2], 'aabb[2] z0');
+        assert.notNaN(aabb[3], 'aabb[3] x1');
+        assert.notNaN(aabb[4], 'aabb[4] y1');
+        assert.notNaN(aabb[5], 'aabb[5] z1');
+
         const address = ELEMENT_WORD_COUNT * id;
         const float32 = this.__data_float32;
 

package/core/bvh2/bvh3/query/compute_tight_near_far_clipping_planes.js

@@ -1,13 +1,156 @@
 //
 
 
+import { array_copy } from "../../../collection/array/copyArray.js";
+import { NULL_NODE } from "../ExplicitBinaryBoundingVolumeHierarchy.js";
+import { aabb3_array_intersects_frustum_degree } from "../../aabb3/aabb3_array_intersects_frustum_degree.js";
+import { bvh_collect_user_data } from "../bvh_collect_user_data.js";
+import { v3_distance_above_plane } from "../../../geom/v3_distance_above_plane.js";
+
+const traversal_stack = [];
+
+const scratch_aabb = [];
+
 /**
- * 
- * @param result
- * @param result_offset
- * @param bvh
- * @param frustum
+ *
+ * @param {number[]} result
+ * @param {number} result_offset
+ * @param {number} constrained_planes_mask if bit is set to 1, that plane is not allowed to move
+ * @param {ExplicitBinaryBoundingVolumeHierarchy} bvh
+ * @param {number[]|ArrayLike<number>|Float32Array} frustum
  */
-export function compute_tight_near_far_clipping_planes(result, result_offset, bvh, frustum) {
+export function compute_tight_near_far_clipping_planes(result, result_offset, constrained_planes_mask, bvh, frustum) {
+    // initialize result
+    array_copy(frustum, 0, result, result_offset, 24);
+
+    const root = bvh.root;
+
+    if (root === NULL_NODE) {
+        return 0;
+    }
+
+    /**
+     *
+     * @type {number}
+     */
+    let traversal_cursor = 1;
+
+    traversal_stack[0] = root;
+
+    let result_cursor = result_offset;
+
+    // 0 is the nearest point along the normal and 1 is the furthest
+    let x0,
+        y0,
+        z0,
+        x1,
+        y1,
+        z1;
+
+    node_loop: while (traversal_cursor > 0) {
+        traversal_cursor--;
+
+        /**
+         *
+         * @type {number}
+         */
+        const node = traversal_stack[traversal_cursor];
+
+        // test node against the ray
+        bvh.node_get_aabb(node, scratch_aabb);
+
+        const _x0 = scratch_aabb[0];
+        const _y0 = scratch_aabb[1];
+        const _z0 = scratch_aabb[2];
+        const _x1 = scratch_aabb[3];
+        const _y1 = scratch_aabb[4];
+        const _z1 = scratch_aabb[5];
+
+        for (let i = 0; i < 6; i++) {
+            const plane_address = i * 4;
+
+            //read out plane
+            const plane_normal_x = frustum[plane_address];
+            const plane_normal_y = frustum[plane_address + 1];
+            const plane_normal_z = frustum[plane_address + 2];
+            const plane_offset = frustum[plane_address + 3];
+
+
+            // construct nearest and farthest corners along the plane normal
+            if (plane_normal_x > 0) {
+                x0 = _x0;
+                x1 = _x1;
+            } else {
+                x0 = _x1;
+                x1 = _x0;
+            }
+
+            if (plane_normal_y > 0) {
+                y0 = _y0;
+                y1 = _y1;
+            } else {
+                y0 = _y1;
+                y1 = _y0;
+            }
+
+            if (plane_normal_z > 0) {
+                z0 = _z0;
+                z1 = _z1;
+            } else {
+                z0 = _z1;
+                z1 = _z0;
+            }
+
+            const distance_above_plane = v3_distance_above_plane(
+                x1, y1, z1,
+                plane_normal_x, plane_normal_y, plane_normal_z, plane_offset
+            );
+
+            if (distance_above_plane < 0) {
+                // below plane, reject this branch
+                continue node_loop;
+            }
+
+            if ((constrained_planes_mask & (1 << i)) !== 0) {
+                // plane is constrained, we're done here
+                continue;
+            }
+
+            //
+
+        }
+
+        const intersection = aabb3_array_intersects_frustum_degree(scratch_aabb, frustum);
+
+        if (intersection === 0) {
+            // fully outside
+            continue;
+        }
+
+        const node_is_leaf = bvh.node_is_leaf(node);
+
+        if (!node_is_leaf) {
+
+            if (intersection === 2) {
+                // fully inside, fast collection path
+                result_cursor += bvh_collect_user_data(result, result_cursor, bvh, node);
+            } else {
+                // partially inside
+                // read in-order
+                const child1 = bvh.node_get_child1(node);
+                const child2 = bvh.node_get_child2(node);
+
+                // write to stack in reverse order, so that fist child ends up being visited first
+                traversal_stack[traversal_cursor++] = child1;
+                traversal_stack[traversal_cursor++] = child2;
+            }
+
+        } else {
+            // leaf node
+
+        }
+    }
+
+    // drop stack frame
 
 }

package/core/bvh2/bvh3/query/compute_tight_near_far_clipping_planes.spec.js

@@ -0,0 +1,41 @@
+import { ExplicitBinaryBoundingVolumeHierarchy } from "../ExplicitBinaryBoundingVolumeHierarchy.js";
+import { compute_tight_near_far_clipping_planes } from "./compute_tight_near_far_clipping_planes.js";
+
+
+function orthographic_frustum(left, right, up, down, near, far) {
+    return new Float32Array([
+        1, 0, 0, right,
+        -1, 0, 0, -left,
+        0, 1, 0, down,
+        0, -1, 0, -up,
+        0, 0, 1, far,
+        0, 0, -1, -near
+    ]);
+}
+
+test('Empty', () => {
+    const bvh = new ExplicitBinaryBoundingVolumeHierarchy();
+
+    const res = [];
+
+    const frustum = new Float32Array(24);
+
+    compute_tight_near_far_clipping_planes(res, 0, 0b000011, bvh, frustum);
+});
+
+test('Axis-aligned, orthographic tight fit around a single small node', () => {
+    const frustum = orthographic_frustum(-1, 1, -1, 1, -1, 1);
+
+    const bvh = new ExplicitBinaryBoundingVolumeHierarchy();
+
+    const leaf = bvh.allocate_node();
+    bvh.node_set_aabb(leaf, [-0.1, -0.1, -0.1, 0.1, 0.1, 0.1]);
+    bvh.insert_leaf(leaf);
+
+    const res = [];
+
+    compute_tight_near_far_clipping_planes(res, 0, 0b000011, bvh, frustum);
+
+    expect(res[4 * 4 + 3]).toBeCloseTo(0.1);
+    expect(res[4 * 5 + 3]).toBeCloseTo(0.1);
+});

package/core/bvh2/traversal/ThreeClippingPlaneComputingBVHVisitor.js

@@ -1,9 +1,9 @@
-import { computePointDistanceToPlane } from "../../geom/Plane.js";
 import { BVHVisitor } from "./BVHVisitor.js";
 import { read_frustum_planes_to_array } from "../../geom/3d/frustum/read_frustum_planes_to_array.js";
 import {
     aabb3_detailed_volume_intersection_callback_based
 } from "./aabb3_detailed_volume_intersection_callback_based.js";
+import { v3_distance_above_plane } from "../../geom/v3_distance_above_plane.js";
 
 export class ThreeClippingPlaneComputingBVHVisitor extends BVHVisitor {
     constructor() {
@@ -113,7 +113,7 @@ export class ThreeClippingPlaneComputingBVHVisitor extends BVHVisitor {
 
         const n = this.__nearPlaneNormal;
 
-        return computePointDistanceToPlane(x, y, z, n.x, n.y, n.z, this.__nearPlaneConstant);
+        return v3_distance_above_plane(x, y, z, n.x, n.y, n.z, this.__nearPlaneConstant);
     }
 
     /**

package/core/bvh2/traversal/__process_point_if_within_planes.js

@@ -1,5 +1,5 @@
-import { computePointDistanceToPlane } from "../../geom/Plane.js";
 import { EPSILON } from "../../math/MathUtils.js";
+import { v3_distance_above_plane } from "../../geom/v3_distance_above_plane.js";
 
 /**
  *
@@ -39,7 +39,7 @@ export function __process_point_if_within_planes(
         const nz = planes[plane_address + 2];
         const c = planes[plane_address + 3];
 
-        const distance_to_plane = computePointDistanceToPlane(x, y, z, nx, ny, nz, c);
+        const distance_to_plane = v3_distance_above_plane(x, y, z, nx, ny, nz, c);
 
         if (distance_to_plane < -EPSILON) {
             // point is outside of one of the planes

package/core/bvh2/traversal/aabb3_detailed_volume_intersection_callback_based.js

@@ -43,10 +43,13 @@ export function aabb3_detailed_volume_intersection_callback_based(
     );
 
     for (let i = 0; i < point_count; i++) {
+
         const address = i * 3;
+
         const x = scratch_points_data[address];
         const y = scratch_points_data[address + 1];
         const z = scratch_points_data[address + 2];
+
         callback.call(thisArg,
             x,
             y,

package/core/collection/array/computeHashArray.d.ts

@@ -0,0 +1 @@
+export function computeHashArray<T>(array: T[], hash: (T) => number): number

package/core/color/Color.js

@@ -301,12 +301,15 @@ export class Color {
      * @param {number} v 0..1
      */
     setHSV(h, s, v) {
-        let _h = h % 1;
+        let _h = h;
 
         if (_h < 0) {
-            _h = h + 1;
+            // move into positive range
+            _h = _h + Math.ceil(Math.abs(_h));
         }
 
+        _h = _h % 1
+
         const _s = clamp01(s);
         const _v = clamp01(v);
 
@@ -409,7 +412,8 @@ export class Color {
      * @param {Color} other
      */
     copy(other) {
-        this.setRGB(this.r, this.g, this.b);
+        this.a = other.a;
+        this.setRGB(other.r, other.g, other.b);
     }
 
     /**

package/core/geom/3d/aabb/aabb3_computeDistanceAbovePlane_max.spec.js

@@ -0,0 +1,8 @@
+import { aabb3_computeDistanceAbovePlane_max } from "./aabb3_compute_distance_above_plane_max.js";
+
+test('cube above orthographic plane',()=>{
+    expect(aabb3_computeDistanceAbovePlane_max(
+        0,1,0,-1,
+        -1,3,-1,1,5,1
+    )).toBe(4);
+});

package/core/geom/3d/aabb/{aabb3_computeDistanceAbovePlane.js → aabb3_compute_distance_above_plane_max.js}

@@ -1,4 +1,5 @@
 /**
+ * Distance of the farthest point along the plane normal from the plane. If the result is >= 0, at least a portion of AABB pokes above the plane
  * @param {number} plane_normal_x
  * @param {number} plane_normal_y
  * @param {number} plane_normal_z
@@ -11,13 +12,13 @@
  * @param {number} _z1
  * @returns {number}
  */
-export function aabb3_computeDistanceAbovePlane(
+export function aabb3_computeDistanceAbovePlane_max(
     plane_normal_x, plane_normal_y, plane_normal_z, plane_constant,
     _x0, _y0, _z0,
     _x1, _y1, _z1
 ) {
 
-    // pick a corner point furthest along the plane normal
+    // pick a corner point nearest along the plane normal
     const px = plane_normal_x > 0 ? _x1 : _x0;
     const py = plane_normal_y > 0 ? _y1 : _y0;
     const pz = plane_normal_z > 0 ? _z1 : _z0;

package/core/geom/3d/aabb/computeAABB3PlaneSide.js

@@ -1,4 +1,4 @@
-import { computePointDistanceToPlane } from "../../Plane.js";
+import { v3_distance_above_plane } from "../../v3_distance_above_plane.js";
 
 /**
  * 2,0,or -2; 2: above, -2 : below, 0 : intersects plane
@@ -62,7 +62,7 @@ export function computeAABB3PlaneSide(
 
     // check the nearest corner
 
-    if (computePointDistanceToPlane(x0, y0, z0, plane_normal_x, plane_normal_y, plane_normal_z, plane_constant) >= 0) {
+    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 {
@@ -71,7 +71,7 @@ export function computeAABB3PlaneSide(
 
     // check the farthest corner
 
-    if (computePointDistanceToPlane(x1, y1, z1, plane_normal_x, plane_normal_y, plane_normal_z, plane_constant) >= 0) {
+    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 {

package/core/geom/3d/frustum/frustum3_computeNearestPointToPoint.js

@@ -1,8 +1,9 @@
-import { computePlanePlaneIntersection, computePointDistanceToPlane } from "../../Plane.js";
+import { computePlanePlaneIntersection } from "../../Plane.js";
 import Vector3 from "../../Vector3.js";
 import { plane3_projectPoint } from "../plane/plane3_projectPoint.js";
 import { plane_three_computeConvex3PlaneIntersection } from "../plane/plane_computeConvex3PlaneIntersection.js";
 import { ray_computeNearestPointToPoint } from "../ray/ray_computeNearestPointToPoint.js";
+import { v3_distance_above_plane } from "../../v3_distance_above_plane.js";
 
 /**
  *
@@ -42,7 +43,7 @@ export function frustum3_computeNearestPointToPoint(result, planes, target_x, ta
 
         const plane_normal = plane.normal;
 
-        const distance = computePointDistanceToPlane(
+        const distance = v3_distance_above_plane(
             target_x, target_y, target_z,
             plane_normal.x, plane_normal.y, plane_normal.z, plane.constant
         );

package/core/geom/3d/plane/is_point_within_planes.js

@@ -1,5 +1,5 @@
-import { computePointDistanceToPlane } from "../../Plane.js";
 import { EPSILON } from "../../../math/MathUtils.js";
+import { v3_distance_above_plane } from "../../v3_distance_above_plane.js";
 
 /**
  *
@@ -34,7 +34,7 @@ export function is_point_within_planes(
         const nz = planes[plane_address + 2];
         const c = planes[plane_address + 3];
 
-        const distance_to_plane = computePointDistanceToPlane(x, y, z, nx, ny, nz, c);
+        const distance_to_plane = v3_distance_above_plane(x, y, z, nx, ny, nz, c);
 
         if (distance_to_plane < -EPSILON) {
             // point is outside of one of the planes

package/core/geom/3d/plane/plane3_projectPoint.js

@@ -1,4 +1,4 @@
-import { computePointDistanceToPlane } from "../../Plane.js";
+import { v3_distance_above_plane } from "../../v3_distance_above_plane.js";
 
 /**
  *
@@ -12,7 +12,7 @@ import { computePointDistanceToPlane } from "../../Plane.js";
  * @param {number} plane_offset
  */
 export function plane3_projectPoint(result, point_x, point_y, point_z, normal_x, normal_y, normal_z, plane_offset) {
-    const distance = computePointDistanceToPlane(point_x, point_y, point_z, normal_x, normal_y, normal_z, plane_offset);
+    const distance = v3_distance_above_plane(point_x, point_y, point_z, normal_x, normal_y, normal_z, plane_offset);
 
     const negative_distance = -distance;