@woosh/meep-engine 2.33.19 → 2.33.23

package/core/assert.js

@@ -332,7 +332,9 @@ assert.notNull = function (value, name = "value") {
  * @param {string} name
  */
 assert.notNaN = function (value, name = "value") {
-    assert.ok(!Number.isNaN(value), `${name} must be a valid number, instead was NaN`);
+    if (Number.isNaN(value)) {
+        throw new Error(`${name} must be a valid number, instead was NaN`);
+    }
 };
 
 /**

package/core/bvh2/traversal/__detailed_box_volume_intersection.js

@@ -4,9 +4,8 @@ import { computePointDistanceToPlane, plane3_computeLineSegmentIntersection } fr
 import { aabb3_corner_edge_mapping } from "../aabb3/aabb3_corner_edge_mapping.js";
 import { aabb3_edge_corner_mapping } from "../aabb3/aabb3_edge_corner_mapping.js";
 import { __process_point_if_within_planes } from "./__process_point_if_within_planes.js";
-import { plane_computeConvex3PlaneIntersection } from "../../geom/3d/plane_computeConvex3PlaneIntersection.js";
+import { plane_computeConvex3PlaneIntersection } from "../../geom/3d/plane/plane_computeConvex3PlaneIntersection.js";
 import { EPSILON } from "../../math/MathUtils.js";
-import Vector3 from "../../geom/Vector3.js";
 
 /**
  *
@@ -26,7 +25,11 @@ const scratch_aabb_planes = new Float32Array(24);
  */
 const scratch_corner_out_bitfields = new Uint32Array(8);
 
-const scratch_v3 = new Vector3();
+/**
+ *
+ * @type {number[]}
+ */
+const scratch_v3_array = new Float32Array(3);
 
 /**
  *
@@ -183,7 +186,7 @@ export function __detailed_box_volume_intersection(
             const c = planes[plane_address + 3];
 
             const edge_intersects = plane3_computeLineSegmentIntersection(
-                scratch_v3,
+                scratch_v3_array, 0,
                 corner_0_x, corner_0_y, corner_0_z,
                 corner_1_x, corner_1_y, corner_1_z,
                 nx, ny, nz, c
@@ -192,7 +195,7 @@ export function __detailed_box_volume_intersection(
             if (edge_intersects) {
                 // a possible candidate, let's see if this point is within rest of the planes
                 __process_point_if_within_planes(
-                    scratch_v3.x, scratch_v3.y, scratch_v3.z,
+                    scratch_v3_array[0], scratch_v3_array[1], scratch_v3_array[2],
                     (plane_mask ^ plane_bit_mask),
                     planes,
                     plane_count,
@@ -230,7 +233,7 @@ export function __detailed_box_volume_intersection(
             const cp_1 = next_orthogonal_plane_index * 4;
 
             const intersection_exists = plane_computeConvex3PlaneIntersection(
-                scratch_v3,
+                scratch_v3_array, 0,
                 aabb_plane_nx, aabb_plane_ny, aabb_plane_nz, aabb_plane_constant,
                 planes[cp_0], planes[cp_0 + 1], planes[cp_0 + 2], planes[cp_0 + 3],
                 planes[cp_1], planes[cp_1 + 1], planes[cp_1 + 2], planes[cp_1 + 3]
@@ -238,14 +241,14 @@ export function __detailed_box_volume_intersection(
 
             if (intersection_exists) {
 
-                const point_within_box = box.containsPointWithTolerance(scratch_v3.x, scratch_v3.y, scratch_v3.z, EPSILON);
+                const point_within_box = box.containsPointWithTolerance(scratch_v3_array[0], scratch_v3_array[1], scratch_v3_array[2], EPSILON);
 
                 if (point_within_box) {
                     // point is within the AABB bounds
 
                     // ThreeClippingPlaneComputingBVHVisitor.DEBUG_POINTS_2.send3(scratch_v3.x, scratch_v3.y, scratch_v3.z);
 
-                    callback.call(thisArg, scratch_v3.x, scratch_v3.y, scratch_v3.z);
+                    callback.call(thisArg, scratch_v3_array[0], scratch_v3_array[1], scratch_v3_array[2]);
                 }
             }
         }

package/core/collection/HashMap.js

@@ -26,6 +26,18 @@ class MapEntry {
     }
 }
 
+/**
+ * @readonly
+ * @type {number}
+ */
+const DEFAULT_INITIAL_CAPACITY = 16;
+
+/**
+ * @readonly
+ * @type {number}
+ */
+const DEFAULT_LOAD_FACTOR = 0.75;
+
 /**
  * Implements part of {@link Map} interface
  * @template K,V
@@ -36,10 +48,14 @@ export class HashMap {
      * @template K, V
      * @param {function(K):number} [keyHashFunction]
      * @param {function(K,K):boolean} [keyEqualityFunction]
+     * @param {number} [capacity] initial number of buckets in the hash table
+     * @param {number} [loadFactor] a measure of how full the hash table is allowed to get before its capacity is automatically increased
      */
     constructor({
                     keyHashFunction = invokeObjectHash,
-                    keyEqualityFunction = invokeObjectEquals
+                    keyEqualityFunction = invokeObjectEquals,
+                    capacity = DEFAULT_INITIAL_CAPACITY,
+                    loadFactor = DEFAULT_LOAD_FACTOR
                 } = {}) {
         assert.typeOf(keyHashFunction, 'function', 'keyHashFunction');
         assert.typeOf(keyEqualityFunction, 'function', 'keyEqualityFunction');
@@ -69,14 +85,21 @@ export class HashMap {
          * @type {number}
          * @private
          */
-        this.__bucket_count = 16384;
+        this.__bucket_count = capacity;
+
+        /**
+         * How full the table can get before number of buckets is increased
+         * @type {number}
+         * @private
+         */
+        this.__load_factor = loadFactor;
     }
 
     /**
      * Proportion between actual number of records in the map and the bucket count (number of potential hashes)
      * @returns {number}
      */
-    getLoadFactor() {
+    getCurrentLoad() {
         return this.size / this.__bucket_count;
     }
 
@@ -133,7 +156,7 @@ export class HashMap {
         this.__bucket_count = count;
         if (this.size > 0) {
             // re-hash
-            this.updateHashes();
+            this.rebuild();
         }
     }
 
@@ -167,31 +190,49 @@ export class HashMap {
         let bucket = this.records[bucket_index];
 
         if (bucket === undefined) {
-            bucket = [new MapEntry(key, value)];
+
+            // bucket for this value doesn't exist
+
+            bucket = [];
+
             this.records[bucket_index] = bucket;
 
-            this.size++;
+        } else {
 
-            return;
-        }
+            // bucket exists
 
-        const bucketSize = bucket.length;
+            const bucketSize = bucket.length;
 
-        //check if key already exists
-        for (let i = 0; i < bucketSize; i++) {
-            const entry = bucket[i];
+            //check if key already exists
+            for (let i = 0; i < bucketSize; i++) {
+                const entry = bucket[i];
 
-            const entryKey = entry.key;
-            if (entryKey === key || this.keyEqualityFunction(entryKey, key)) {
+                const entryKey = entry.key;
 
-                entry.value = value;
-                return;
+                if (entryKey === key || this.keyEqualityFunction(entryKey, key)) {
+
+                    entry.value = value;
+                    return;
+
+                }
 
             }
+
         }
 
         bucket.push(new MapEntry(key, value));
-        this.size++;
+
+        const old_size = this.size;
+        const new_size = old_size + 1;
+        this.size = new_size;
+
+        // compute actual current load
+        const load = new_size / this.__bucket_count;
+
+        if (load > this.__load_factor) {
+            // increase table size
+            this.setBucketCount(this.__bucket_count * 2);
+        }
     }
 
     /**
@@ -308,20 +349,22 @@ export class HashMap {
     }
 
     /**
-     *
+     * Rebuild table, useful for when table is resized or hashes of stored keys change
      */
-    updateHashes() {
+    rebuild() {
 
         let h, i, l;
 
         const records = this.records;
 
         for (h in records) {
+            const stored_bucket_index = parseInt(h);
+
             if (!records.hasOwnProperty(h)) {
                 continue;
             }
 
-            const bucket = records[h];
+            const bucket = records[stored_bucket_index];
 
             for (i = 0, l = bucket.length; i < l; i++) {
                 /**
@@ -333,7 +376,6 @@ export class HashMap {
                 const raw_hash = this.keyHashFunction(entry.key);
                 const actual_bucket_index = this.__compute_bucket_index(raw_hash);
 
-                const stored_bucket_index = parseInt(h);
 
                 if (actual_bucket_index !== stored_bucket_index) {
                     //remove entry from the bucket
@@ -345,15 +387,17 @@ export class HashMap {
 
                     if (bucket.length === 0) {
                         //delete empty bucket
-                        delete records[h];
+                        delete records[stored_bucket_index];
                     }
 
                     const newBucket = records[actual_bucket_index];
+
                     if (newBucket === undefined) {
                         records[actual_bucket_index] = [entry];
                     } else {
                         newBucket.push(entry);
                     }
+
                 }
             }
         }

package/core/geom/3d/CircleMath.js

@@ -1,4 +1,4 @@
-import { v3_angleBetween } from "../Vector3.js";
+import { v3_angle_between } from "../v3_angle_between.js";
 
 /**
  * NOTE: based on https://stackoverflow.com/questions/2592011/bounding-boxes-for-circle-and-arcs-in-3d
@@ -12,9 +12,9 @@ import { v3_angleBetween } from "../Vector3.js";
  * @param {number} radius
  */
 export function computeCircleBoundingBox(result, centerX, centerY, centerZ, normalX, normalY, normalZ, radius) {
-    const ax = v3_angleBetween(normalX, normalY, normalZ, 1, 0, 0);
-    const ay = v3_angleBetween(normalX, normalY, normalZ, 0, 1, 0);
-    const az = v3_angleBetween(normalX, normalY, normalZ, 0, 0, 1);
+    const ax = v3_angle_between(normalX, normalY, normalZ, 1, 0, 0);
+    const ay = v3_angle_between(normalX, normalY, normalZ, 0, 1, 0);
+    const az = v3_angle_between(normalX, normalY, normalZ, 0, 0, 1);
 
     const rX = Math.sin(ax) * radius;
     const rY = Math.sin(ay) * radius;

package/core/geom/3d/cone/computeConeBoundingBox.js

@@ -1,6 +1,6 @@
 import { max2 } from "../../../math/max2.js";
 import { min2 } from "../../../math/min2.js";
-import { v3_angleBetween } from "../../Vector3.js";
+import { v3_angle_between } from "../../v3_angle_between.js";
 
 /**
  * NOTE: used stackoverflow answer as a basis for circle part: https://stackoverflow.com/questions/2592011/bounding-boxes-for-circle-and-arcs-in-3d
@@ -15,9 +15,9 @@ import { v3_angleBetween } from "../../Vector3.js";
  * @param {number} length
  */
 export function computeConeBoundingBox(result, originX, originY, originZ, directionX, directionY, directionZ, angle, length) {
-    const ax = v3_angleBetween(directionX, directionY, directionZ, 1, 0, 0);
-    const ay = v3_angleBetween(directionX, directionY, directionZ, 0, 1, 0);
-    const az = v3_angleBetween(directionX, directionY, directionZ, 0, 0, 1);
+    const ax = v3_angle_between(directionX, directionY, directionZ, 1, 0, 0);
+    const ay = v3_angle_between(directionX, directionY, directionZ, 0, 1, 0);
+    const az = v3_angle_between(directionX, directionY, directionZ, 0, 0, 1);
 
     //compute radius of the base of the cone
     const radius = length * Math.tan(angle);

package/core/geom/3d/{compute_bounding_cone_of_2_cones.js → cone/compute_bounding_cone_of_2_cones.js}

@@ -1,9 +1,9 @@
 //
 
 
-import Vector3 from "../Vector3.js";
-import Quaternion, { quat3_createFromAxisAngle } from "../Quaternion.js";
-import { max2 } from "../../math/max2.js";
+import Vector3 from "../../Vector3.js";
+import Quaternion, { quat3_createFromAxisAngle } from "../../Quaternion.js";
+import { max2 } from "../../../math/max2.js";
 
 const tangent = new Vector3();
 

package/core/geom/3d/{compute_bounding_cone_of_2_cones.spec.js → cone/compute_bounding_cone_of_2_cones.spec.js}

@@ -1,5 +1,5 @@
 import { compute_bounding_cone_of_2_cones } from "./compute_bounding_cone_of_2_cones.js";
-import { ConicRay } from "../ConicRay.js";
+import { ConicRay } from "../../ConicRay.js";
 
 /**
  *

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

@@ -1,4 +1,4 @@
-import { v3_length } from "../../Vector3.js";
+import { v3_length } from "../../v3_length.js";
 
 /**
  *

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

@@ -2,7 +2,7 @@ import { ray_computeNearestPointToPoint } from "../../LineSegment.js";
 import { computePlanePlaneIntersection, computePointDistanceToPlane } from "../../Plane.js";
 import Vector3 from "../../Vector3.js";
 import { plane3_projectPoint } from "../plane/plane3_projectPoint.js";
-import { plane_three_computeConvex3PlaneIntersection } from "../plane_computeConvex3PlaneIntersection.js";
+import { plane_three_computeConvex3PlaneIntersection } from "../plane/plane_computeConvex3PlaneIntersection.js";
 
 /**
  *
@@ -14,6 +14,12 @@ const scratch_v3_0 = new Vector3();
 
 const scratch_v3_1 = new Vector3();
 
+/**
+ *
+ * @type {number[]}
+ */
+const scratch_v3_array = [];
+
 /**
  *
  * @param {Vector3} result
@@ -94,7 +100,9 @@ export function frustum3_computeNearestPointToPoint(result, planes, target_x, ta
         const plane_1 = planes[plane_1_index];
         const plane_2 = planes[plane_2_index];
 
-        plane_three_computeConvex3PlaneIntersection(result, plane_0, plane_1, plane_2);
+        plane_three_computeConvex3PlaneIntersection(scratch_v3_array, 0, plane_0, plane_1, plane_2);
+
+        result.readFromArray(scratch_v3_array, 0)
     }
 
     return false;

package/core/geom/3d/{unit_hemioct.spec.js → normal/hemioct/unit_hemioct.spec.js}

@@ -1,5 +1,5 @@
 import { decode_hemioct_to_unit, encode_unit_to_hemioct } from "./encode_unit3_hemioct.js";
-import { v3_length } from "../Vector3.d.ts";
+import { v3_length } from "../../../Vector3.d.ts";
 
 test('encode-decode', () => {
     const v0 = [];

package/core/geom/3d/normal/lamber_azimuth/transform.js

@@ -0,0 +1,61 @@
+import { v2_dot } from "../../../Vector2.js";
+
+/*
+@source https://aras-p.info/texts/CompactNormalStorage.html
+@source https://en.wikipedia.org/wiki/Lambert_azimuthal_equal-area_projection
+
+half2 encode (half3 n, float3 view)
+{
+    half f = sqrt(8*n.z+8);
+    return n.xy / f + 0.5;
+}
+half3 decode (half4 enc, float3 view)
+{
+    half2 fenc = enc*4-2;
+    half f = dot(fenc,fenc);
+    half g = sqrt(1-f/4);
+    half3 n;
+    n.xy = fenc*g;
+    n.z = 1-f/2;
+    return n;
+}
+ */
+
+/**
+ *
+ * @param {number[]} output
+ * @param {number} output_offset
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ */
+export function encode_unit_to_azimuth(output, output_offset, x, y, z) {
+    const f = Math.sqrt(8 * z + 8);
+
+    output[output_offset] = x / f + 0.5;
+    output[output_offset + 1] = y / f + 0.5;
+}
+
+/**
+ *
+ * @param {number[]} output
+ * @param {number} output_offset
+ * @param {number} x range [-1,1]
+ * @param {number} y range [-1,1]
+ */
+export function decode_azimuth_to_unit(output, output_offset, x, y) {
+    const fenc_x = x * 4 - 2;
+    const fenc_y = y * 4 - 2;
+
+    const f = v2_dot(fenc_x, fenc_y, fenc_x, fenc_y);
+
+    const g = Math.sqrt(1 - f / 4);
+
+    const n_x = fenc_x * g;
+    const n_y = fenc_y * g;
+    const n_z = 1 - f / 2;
+
+    output[output_offset] = n_x;
+    output[output_offset + 1] = n_y;
+    output[output_offset + 2] = n_z;
+}

package/core/geom/3d/normal/spherical/sphere_map_transform.js

@@ -0,0 +1,77 @@
+import { v2_magnitude } from "../../../Vector2.js";
+import { v3_dot } from "../../../v3_dot.js";
+
+/*
+@source https://aras-p.info/texts/CompactNormalStorage.html#method04spheremap
+@source Siggraph 99
+@source Cry Engine 3, presented by Martin Mittring in "A bit more Deferred"
+
+half2 encode (half3 n, float3 view)
+{
+    half2 enc = normalize(n.xy) * (sqrt(-n.z*0.5+0.5));
+    enc = enc*0.5+0.5;
+    return enc;
+}
+half3 decode (half4 enc, float3 view)
+{
+    half4 nn = enc*half4(2,2,0,0) + half4(-1,-1,1,-1);
+    half l = dot(nn.xyz,-nn.xyw);
+    nn.z = l;
+    nn.xy *= sqrt(l);
+    return nn.xyz * 2 + half3(0,0,-1);
+}
+ */
+
+
+/**
+ * Encode v3 to v2
+ * @param {number[]} output
+ * @param {number} output_offset
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ */
+export function encode_unit_to_spheremap(output, output_offset, x, y, z) {
+    const length_xy = v2_magnitude(x, y);
+
+    const norm_xy_x = x / length_xy;
+    const norm_xy_y = y / length_xy;
+
+    const z_factor = Math.sqrt(-z * 0.5 - 0.5) * 0.5;
+
+    const enc_x = norm_xy_x * z_factor + 0.5;
+    const enc_y = norm_xy_y * z_factor + 0.5;
+
+    output[output_offset] = enc_x;
+    output[output_offset + 1] = enc_y;
+}
+
+/**
+ * @param {number[]} output
+ * @param {number} output_offset
+ * @param {number} x range [-1,1]
+ * @param {number} y range [-1,1]
+ */
+function decode_spheremap_to_unit(output, output_offset, x, y) {
+    const nn4_x = x * 2 - 1;
+    const nn4_y = y * 2 - 1;
+    const nn4_z = 1;
+    const nn4_w = -1;
+
+    const l = v3_dot(nn4_x, nn4_y, nn4_z, -nn4_x, -nn4_y, -nn4_w);
+
+    const nn_z = l;
+
+    const l_sqrt = Math.sqrt(l);
+
+    const nn_x = nn4_x * l_sqrt;
+    const nn_y = nn4_y * l_sqrt;
+
+    const _x = nn_x * 2;
+    const _y = nn_y * 2;
+    const _z = nn_z * 2 - 1;
+
+    output[output_offset] = _x;
+    output[output_offset + 1] = _y;
+    output[output_offset + 2] = _z;
+}

package/core/geom/3d/{lerp_planes_to_array.js → plane/lerp_planes_to_array.js}

@@ -1,6 +1,4 @@
-import Vector3, { v3_dot } from "../Vector3.js";
-
-const t_v3 = new Vector3();
+import { v3_dot } from "../../v3_dot.js";
 
 /**
  * Calculate a plane that is a linear interpolation between two other planes A and B with interpolation factor between 0 and 1

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

@@ -1,6 +1,8 @@
 import { lerp } from "../../../math/lerp.js";
-import Vector3, { v3_dot, v3_length } from "../../Vector3.js";
+import Vector3 from "../../Vector3.js";
 import { plane3_intersect_plane } from "./plane3_intersect_plane.js";
+import { v3_dot } from "../../v3_dot.js";
+import { v3_length } from "../../v3_length.js";
 
 const v0 = new Vector3();
 const v1 = new Vector3();

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

@@ -1,6 +1,9 @@
 import { lerp } from "../../../math/lerp.js";
 import { EPSILON } from "../../../math/MathUtils.js";
-import Vector3, { v3_dot, v3_length_sqr, v3_slerp } from "../../Vector3.js";
+import Vector3 from "../../Vector3.js";
+import { v3_dot } from "../../v3_dot.js";
+import { v3_length_sqr } from "../../v3_length_sqr.js";
+import { v3_slerp } from "../../v3_slerp.js";
 
 const e = new Vector3();
 

package/core/geom/3d/{plane_computeConvex3PlaneIntersection.js → plane/plane_computeConvex3PlaneIntersection.js}

@@ -1,21 +1,22 @@
-import { v3_dot } from "../Vector3.js";
-
+import { v3_dot } from "../../v3_dot.js";
 
 /**
  *
- * @param {Vector3} result
+ * @param {number[]} result
+ * @param {number} result_offset
  * @param {Plane} a
  * @param {Plane} b
  * @param {Plane} c
  * @returns {boolean}
  */
-export function plane_three_computeConvex3PlaneIntersection(result, a, b, c) {
+export function plane_three_computeConvex3PlaneIntersection(result, result_offset, a, b, c) {
     const a_normal = a.normal;
     const b_normal = b.normal;
     const c_normal = c.normal;
 
     return plane_computeConvex3PlaneIntersection(
         result,
+        result_offset,
         a_normal.x, a_normal.y, a_normal.z, a.constant,
         b_normal.x, b_normal.y, b_normal.z, b.constant,
         c_normal.x, c_normal.y, c_normal.z, c.constant,
@@ -24,7 +25,8 @@ export function plane_three_computeConvex3PlaneIntersection(result, a, b, c) {
 
 /**
  * NOTE: Based on Intersection of 3 planes, Graphics Gems 1 pg 305
- * @param {Vector3} result
+ * @param {Float32Array|number[]|vec3} result
+ * @param {number} result_offset
  * @param {number} a_normal_x
  * @param {number} a_normal_y
  * @param {number} a_normal_z
@@ -40,7 +42,7 @@ export function plane_three_computeConvex3PlaneIntersection(result, a, b, c) {
  * @returns {boolean} true if planes intersect, false otherwise
  */
 export function plane_computeConvex3PlaneIntersection(
-    result,
+    result, result_offset,
     a_normal_x, a_normal_y, a_normal_z, a_constant,
     b_normal_x, b_normal_y, b_normal_z, b_constant,
     c_normal_x, c_normal_y, c_normal_z, c_constant
@@ -75,18 +77,14 @@ export function plane_computeConvex3PlaneIntersection(
     const d = 1 / determinant;
 
     const neg_a_constant = -a_constant;
-    const neg_b_constant = -b_constant;
-    const neg_c_constant = -c_constant;
 
-    const x = (bxc_x * neg_a_constant + cxa_x * neg_b_constant + axb_x * neg_c_constant) * d;
-    const y = (bxc_y * neg_a_constant + cxa_y * neg_b_constant + axb_y * neg_c_constant) * d;
-    const z = (bxc_z * neg_a_constant + cxa_z * neg_b_constant + axb_z * neg_c_constant) * d;
+    const x = (bxc_x * neg_a_constant - cxa_x * b_constant - axb_x * c_constant) * d;
+    const y = (bxc_y * neg_a_constant - cxa_y * b_constant - axb_y * c_constant) * d;
+    const z = (bxc_z * neg_a_constant - cxa_z * b_constant - axb_z * c_constant) * d;
 
-    result.set(
-        x,
-        y,
-        z
-    );
+    result[result_offset] = x;
+    result[result_offset + 1] = y;
+    result[result_offset + 2] = z;
 
     return true;
 }

package/core/geom/3d/topology/TopoTriangle.js

@@ -1,9 +1,9 @@
-import { v3_length } from "../../Vector3.js";
 import { array_replace_all } from "../../../collection/array/array_replace_all.js";
 import { array_push_if_unique } from "../../../collection/array/array_push_if_unique.js";
 import { assert } from "../../../assert.js";
 import { array_remove_first } from "../../../collection/array/array_remove_first.js";
 import { vec3 } from "gl-matrix";
+import { v3_length } from "../../v3_length.js";
 
 /**
  *

package/core/geom/3d/topology/TopoVertex.js

@@ -1,7 +1,7 @@
-import { v3_distance } from "../../Vector3.js";
 import { assert } from "../../../assert.js";
 import { array_push_if_unique } from "../../../collection/array/array_push_if_unique.js";
 import { array_remove_first } from "../../../collection/array/array_remove_first.js";
+import { v3_distance } from "../../v3_distance.js";
 
 export class TopoVertex {
     constructor() {

package/core/geom/3d/topology/bounds/computeTraingleClusterNormalBoundingCone.js

@@ -1,9 +1,9 @@
 import { Miniball } from "../../../packing/miniball/Miniball.js";
 import { PointSet } from "../../../packing/miniball/PointSet.js";
 import { ConicRay } from "../../../ConicRay.js";
-import { v3_angleBetween } from "../../../Vector3.js";
 import { array_copy } from "../../../../collection/array/copyArray.js";
 import { min2 } from "../../../../math/min2.js";
+import { v3_angle_between } from "../../../v3_angle_between.js";
 
 /**
  * Using Shirman and Abi-Ezzi method, compute bounding sphere of points, then build a cone from that
@@ -66,7 +66,7 @@ export function computeTraingleClusterNormalBoundingCone(result, faces) {
         const normal_y = normal_data[i3];
         const normal_z = normal_data[i3];
 
-        const angle = v3_angleBetween(
+        const angle = v3_angle_between(
             normal_x, normal_y, normal_z,
             result_direction.x, result_direction.y, result_direction.z
         );

package/core/geom/3d/topology/simplify/compute_face_normal_change_dot_product.js

@@ -1,4 +1,4 @@
-import { v3_dot } from "../../../Vector3.js";
+import { v3_dot } from "../../../v3_dot.js";
 
 /**
  * Used to detect face normal flips for mesh optimization.