@woosh/meep-engine 2.49.9 → 2.50.1

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

@@ -8,10 +8,12 @@ import { assert } from "../../../assert.js";
 import { clamp } from "../../../math/clamp.js";
 import { max2 } from "../../../math/max2.js";
 import { min2 } from "../../../math/min2.js";
-import LineSegment2 from "../LineSegment2.js";
 import Vector2 from "../../Vector2.js";
 import { aabb2_compute_overlap } from "./aabb2_compute_overlap.js";
 import { aabb2_overlap_exists } from "./aabb2_overlap_exists.js";
+import {
+    line_segment_compute_line_segment_intersection_2d
+} from "../line/line_segment_compute_line_segment_intersection_2d.js";
 
 /**
  *
@@ -215,7 +217,7 @@ class AABB2 {
     }
 
     /**
-     *
+     * NOTE: only 1 intersection point is produced
      * @param {Vector2} p0
      * @param {Vector2} p1
      * @param {Vector2} result
@@ -227,19 +229,19 @@ class AABB2 {
         const x1 = this.x1;
         const y1 = this.y1;
 
-        if (LineSegment2.intersectionPointRaw(p0.x, p0.y, p1.x, p1.y, x0, y0, x1, y0, result)) {
+        if (line_segment_compute_line_segment_intersection_2d(p0.x, p0.y, p1.x, p1.y, x0, y0, x1, y0, result)) {
             //top
             return true;
         }
-        if (LineSegment2.intersectionPointRaw(p0.x, p0.y, p1.x, p1.y, x0, y1, x1, y1, result)) {
+        if (line_segment_compute_line_segment_intersection_2d(p0.x, p0.y, p1.x, p1.y, x0, y1, x1, y1, result)) {
             //bottom
             return true;
         }
-        if (LineSegment2.intersectionPointRaw(p0.x, p0.y, p1.x, p1.y, x0, y0, x0, y1, result)) {
+        if (line_segment_compute_line_segment_intersection_2d(p0.x, p0.y, p1.x, p1.y, x0, y0, x0, y1, result)) {
             //left
             return true;
         }
-        if (LineSegment2.intersectionPointRaw(p0.x, p0.y, p1.x, p1.y, x1, y0, x1, y1, result)) {
+        if (line_segment_compute_line_segment_intersection_2d(p0.x, p0.y, p1.x, p1.y, x1, y0, x1, y1, result)) {
             //right
             return true;
         }
@@ -486,7 +488,7 @@ class AABB2 {
     }
 
     /**
-     *
+     * Set bounds without having to maintain constraint that x0 >= x1 and y0 >= y1
      * @param {number} x0
      * @param {number} y0
      * @param {number} x1

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

@@ -1,4 +1,5 @@
 import AABB2 from "./AABB2.js";
+import Vector2 from "../../Vector2.js";
 
 test('copy', () => {
     const a = new AABB2(1, 2, 5, 11);
@@ -51,3 +52,102 @@ test('equals', () => {
     expect(a.equals(e)).toBe(false);
     expect(a.equals(f)).toBe(false);
 });
+
+test("lineIntersectionPoint", () => {
+    const aabb = new AABB2(1, 1, 2, 2);
+
+    const result = new Vector2();
+
+    expect(aabb.lineIntersectionPoint(new Vector2(0, 0), new Vector2(-1, -1), result)).toBe(false);
+
+    expect(aabb.lineIntersectionPoint(new Vector2(0, 1.5), new Vector2(3, 1.5), result)).toBe(true);
+});
+
+/**
+ *
+ * @param {AABB2} aabb
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} x1
+ * @param {number} y1
+ */
+function expect_aabb_equals(aabb, x0, y0, x1, y1) {
+    expect(aabb.x0).toEqual(x0);
+    expect(aabb.y0).toEqual(y0);
+    expect(aabb.x1).toEqual(x1);
+    expect(aabb.y1).toEqual(y1);
+}
+
+test("setBoundsUnordered", () => {
+
+    const aabb = new AABB2();
+
+    aabb.setBoundsUnordered(2, 3, -5, -7);
+
+    expect_aabb_equals(aabb, -5, -7, 2, 3);
+
+    aabb.setBoundsUnordered(-5, -7, 2, 3);
+
+    expect_aabb_equals(aabb, -5, -7, 2, 3);
+
+    aabb.setBoundsUnordered(-5, 3, 2, -7);
+
+    expect_aabb_equals(aabb, -5, -7, 2, 3);
+
+    aabb.setBoundsUnordered(2, -7, -5, 3);
+
+    expect_aabb_equals(aabb, -5, -7, 2, 3);
+});
+
+test("toJSON", () => {
+
+    const aabb = new AABB2(1, 3, 5, 7);
+
+    expect(aabb.toJSON()).toEqual({
+        x0: 1,
+        y0: 3,
+        x1: 5,
+        y1: 7
+    });
+
+});
+
+test("fromJSON", () => {
+
+    const aabb = new AABB2();
+
+    aabb.fromJSON({
+        x0: 1,
+        y0: 3,
+        x1: 5,
+        y1: 7
+    });
+
+    expect_aabb_equals(aabb, 1, 3, 5, 7);
+});
+
+test("_expandToFitPoint", () => {
+
+    const aabb = new AABB2();
+
+    aabb._expandToFitPoint(0, 0);
+
+    expect_aabb_equals(aabb, 0, 0, 0, 0);
+
+    aabb._expandToFitPoint(-1, 0);
+
+    expect_aabb_equals(aabb, -1, 0, 0, 0);
+
+    aabb._expandToFitPoint(0, -1);
+
+    expect_aabb_equals(aabb, -1, -1, 0, 0);
+
+    aabb._expandToFitPoint(3, 5);
+
+    expect_aabb_equals(aabb, -1, -1, 3, 5);
+
+    aabb._expandToFitPoint(7, 0);
+
+    expect_aabb_equals(aabb, -1, -1, 7, 5);
+
+});

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

@@ -0,0 +1,11 @@
+import { aabb2_compute_center_from_multiple } from "./aabb2_compute_center_from_multiple.js";
+import AABB2 from "./AABB2.js";
+import Vector2 from "../../Vector2.js";
+
+test("single box", () => {
+    const center = aabb2_compute_center_from_multiple([
+        new AABB2(-1, -3, 0, -2)
+    ]);
+
+    expect(center.roughlyEquals(new Vector2(-0.5, -2.5))).toBe(true);
+});

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

@@ -0,0 +1,56 @@
+import { aabb2_compute_overlap } from "./aabb2_compute_overlap.js";
+import AABB2 from "./AABB2.js";
+
+test("no overlap", () => {
+
+    const aabb = new AABB2();
+
+    expect(aabb2_compute_overlap(
+        -1, -1, -1, -1,
+        1, 1, 1, 1,
+        aabb
+    )).toBe(false);
+
+    expect(aabb2_compute_overlap(
+        0, 0, 0, 0,
+        -1, 1, 1, 1,
+        aabb
+    )).toBe(false);
+
+    expect(aabb2_compute_overlap(
+        0, 0, 0, 0,
+        1, -1, 1, 1,
+        aabb
+    )).toBe(false);
+
+    expect(aabb2_compute_overlap(
+        -1, 1, 1, 1,
+        0, 0, 0, 0,
+        aabb
+    )).toBe(false);
+
+    expect(aabb2_compute_overlap(
+        1, -1, 1, 1,
+        0, 0, 0, 0,
+        aabb
+    )).toBe(false);
+
+});
+
+test("partial complex overlap", () => {
+
+    const aabb = new AABB2();
+
+    expect(aabb2_compute_overlap(
+        0, 0, 7, 3,
+        5, 1, 11, 2,
+        aabb
+    )).toBe(true);
+
+    expect(aabb.toJSON()).toEqual({
+        x0: 5,
+        y0: 1,
+        x1: 7,
+        y1: 2
+    });
+});

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

@@ -0,0 +1,40 @@
+import { aabb2_contains } from "./aabb2_contains.js";
+
+test("test", () => {
+
+    expect(aabb2_contains(
+        0, 0, 0, 0,
+        -1, -1, 1, 1
+    )).toBe(false);
+
+    expect(aabb2_contains(
+        0, 0, 0, 0,
+        0, 0, 0, 0
+    )).toBe(true);
+
+    expect(aabb2_contains(
+        -1, -1, 1, 1,
+        0, 0, 0, 0
+    )).toBe(true);
+
+    expect(aabb2_contains(
+        -1, -1, 1, 1,
+        -2, 0, 0, 0
+    )).toBe(false);
+
+    expect(aabb2_contains(
+        -1, -1, 1, 1,
+        0, -2, 0, 0
+    )).toBe(false);
+
+    expect(aabb2_contains(
+        -1, -1, 1, 1,
+        0, 0, 2, 0
+    )).toBe(false);
+
+    expect(aabb2_contains(
+        -1, -1, 1, 1,
+        0, 0, 0, 2
+    )).toBe(false);
+
+});

package/src/core/geom/2d/bvh/Node2.js

@@ -1,4 +1,4 @@
-import AABB2 from "../../AABB2.js";
+import AABB2 from "../aabb/AABB2.js";
 
 export class Node2 extends AABB2 {
     constructor(x0, y0, x1, y1) {

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

@@ -1,6 +1,6 @@
 //
 
-import { array_copy } from "../../../collection/array/copyArray.js";
+import { array_copy } from "../../../collection/array/array_copy.js";
 import { compute_polygon_area_2d } from "../compute_polygon_area_2d.js";
 import { intersect_ray_2d } from "../intersect_ray_2d.js";
 import { UintArrayForCount } from "../../../collection/array/typed/uint_array_for_count.js";

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

@@ -1,4 +1,4 @@
-import { array_copy } from "../../../collection/array/copyArray.js";
+import { array_copy } from "../../../collection/array/array_copy.js";
 import { Uint32Heap } from "../../../collection/heap/Uint32Heap.js";
 import { intersect_ray_2d } from "../intersect_ray_2d.js";
 import { compute_triangle_area_2d } from "../compute_triangle_area_2d.js";

package/src/core/geom/2d/line/line_segment_compute_line_segment_intersection_2d.js

@@ -0,0 +1,35 @@
+import {
+    line_segment_compute_line_segment_intersection_array_2d
+} from "./line_segment_compute_line_segment_intersection_array_2d.js";
+
+const scratch_array = new Float32Array(2);
+
+/**
+ * @param {number} a0_x
+ * @param {number} a0_y
+ * @param {number} a1_x
+ * @param {number} a1_y
+ * @param {number} b0_x
+ * @param {number} b0_y
+ * @param {number} b1_x
+ * @param {number} b1_y
+ * @param {Vector2} result resulting intersection point will be stored here if intersection exists
+ * @returns {boolean} True if segments intersect, False otherwise
+ */
+export function line_segment_compute_line_segment_intersection_2d(
+    a0_x, a0_y, a1_x, a1_y,
+    b0_x, b0_y, b1_x, b1_y,
+    result
+) {
+    const collision = line_segment_compute_line_segment_intersection_array_2d(
+        scratch_array, 0,
+        a0_x, a0_y, a1_x, a1_y,
+        b0_x, b0_y, b1_x, b1_y,
+    );
+
+    if (collision) {
+        result.readFromArray(scratch_array);
+    }
+
+    return collision;
+}

package/src/core/geom/2d/line/line_segment_compute_line_segment_intersection_array_2d.js

@@ -0,0 +1,51 @@
+/**
+ *
+ * Find intersection point between two line segments if they intersect at all
+ * Adapted from answer by iMalc from stackoverflow.com "how do you detect where two line segments intersect"
+ * @link https://stackoverflow.com/questions/563198/how-do-you-detect-where-two-line-segments-intersect
+ *
+ * @param {number[]|Float32Array|Float64Array} result resulting intersection point will be stored here if intersection exists
+ * @param {number} result_offset
+ * @param {number} a0_x
+ * @param {number} a0_y
+ * @param {number} a1_x
+ * @param {number} a1_y
+ * @param {number} b0_x
+ * @param {number} b0_y
+ * @param {number} b1_x
+ * @param {number} b1_y
+ * @return {boolean} True if segments intersect, False otherwise
+ */
+export function line_segment_compute_line_segment_intersection_array_2d(
+    result, result_offset,
+    a0_x, a0_y, a1_x, a1_y,
+    b0_x, b0_y, b1_x, b1_y
+) {
+
+    const s1_x = a1_x - a0_x;
+    const s1_y = a1_y - a0_y;
+    const s2_x = b1_x - b0_x;
+    const s2_y = b1_y - b0_y;
+
+    const dy_02 = a0_y - b0_y;
+    const dx_02 = a0_x - b0_x;
+
+    const inv_denom = 1 / (-s2_x * s1_y + s1_x * s2_y);
+
+    const s = (-s1_y * dx_02 + s1_x * dy_02) * inv_denom;
+    const t = (s2_x * dy_02 - s2_y * dx_02) * inv_denom;
+
+    if (s >= 0 && s <= 1 && t >= 0 && t <= 1) {
+        // Collision detected
+
+        const intercept_x = a0_x + (t * s1_x);
+        const intercept_y = a0_y + (t * s1_y);
+
+        result[result_offset] = intercept_x;
+        result[result_offset + 1] = intercept_y;
+
+        return true;
+    }
+
+    return false; // No collision
+}

package/src/core/geom/2d/line/line_segment_compute_line_segment_intersection_vectors_2d.js

@@ -0,0 +1,15 @@
+import {
+    line_segment_compute_line_segment_intersection_2d
+} from "./line_segment_compute_line_segment_intersection_2d.js";
+
+/**
+ * @param {Vector2} a0 start of first segment
+ * @param {Vector2} a1 end of first segment
+ * @param {Vector2} b0 start of second segment
+ * @param {Vector2} b1 end of second segment
+ * @param {Vector2} result resulting intersection point will be stored here if intersection exists
+ * @returns {boolean} True if segments intersect, False otherwise
+ */
+export function line_segment_compute_line_segment_intersection_vectors_2d(a0, a1, b0, b1, result) {
+    return line_segment_compute_line_segment_intersection_2d(a0.x, a0.y, a1.x, a1.y, b0.x, b0.y, b1.x, b1.y, result);
+}

package/src/core/geom/2d/line/line_segment_compute_line_segment_intersection_vectors_array_2d.js

@@ -0,0 +1,30 @@
+import {
+    line_segment_compute_line_segment_intersection_array_2d
+} from "./line_segment_compute_line_segment_intersection_array_2d.js";
+
+/**
+ * @param {Vector2} p0
+ * @param {Vector2} p1
+ * @param {Vector2} p2
+ * @param {Vector2} p3
+ * @returns {[number,number]}
+ */
+export function line_segment_compute_line_segment_intersection_vectors_array_2d(p0, p1, p2, p3) {
+    const p0_x = p0.x;
+    const p0_y = p0.y;
+    const p1_x = p1.x;
+    const p1_y = p1.y;
+    const p2_x = p2.x;
+    const p2_y = p2.y;
+    const p3_x = p3.x;
+    const p3_y = p3.y;
+
+    const result = [];
+
+    if (line_segment_compute_line_segment_intersection_array_2d(result, 0, p0_x, p0_y, p1_x, p1_y, p2_x, p2_y, p3_x, p3_y)) {
+        return result;
+    } else {
+        return null; // No collision
+    }
+
+}

package/src/core/geom/2d/line/line_segment_line_segment_intersection_exists_2d.js

@@ -0,0 +1,29 @@
+/**
+ *
+ * @param {number} a0_x
+ * @param {number} a0_y
+ * @param {number} a1_x
+ * @param {number} a1_y
+ * @param {number} b0_x
+ * @param {number} b0_y
+ * @param {number} b1_x
+ * @param {number} b1_y
+ * @returns {boolean} True if segments intersect, False otherwise
+ * @public
+ */
+export function line_segment_line_segment_intersection_exists_2d(a0_x, a0_y, a1_x, a1_y, b0_x, b0_y, b1_x, b1_y) {
+    const s1_x = a1_x - a0_x;
+    const s1_y = a1_y - a0_y;
+    const s2_x = b1_x - b0_x;
+    const s2_y = b1_y - b0_y;
+
+    const dy_02 = a0_y - b0_y;
+    const dx_02 = a0_x - b0_x;
+
+    const inv_denom = 1 / (-s2_x * s1_y + s1_x * s2_y);
+
+    const s = (-s1_y * dx_02 + s1_x * dy_02) * inv_denom;
+    const t = (s2_x * dy_02 - s2_y * dx_02) * inv_denom;
+
+    return s >= 0 && s <= 1 && t >= 0 && t <= 1;
+}

package/src/core/geom/3d/aabb/AABB3.d.ts

@@ -12,6 +12,8 @@ export class AABB3 {
 
     setBounds(x0: number, y0: number, z0: number, x1: number, y1: number, z1: number): void
 
+    setBoundsUnordered(x0: number, y0: number, z0: number, x1: number, y1: number, z1: number): void
+
     getCenter(target: Vector3): void
 
     getCenterX(): number
@@ -43,4 +45,6 @@ export class AABB3 {
     equals(other: AABB3): boolean
 
     copy(other: AABB3): void
+
+    _isBelowPlane(nx: number, ny: number, nz: number, constant: number): boolean
 }

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

@@ -6,6 +6,12 @@ import { serializeAABB3 } from "./serializeAABB3.js";
 import { deserializeAABB3 } from "./deserializeAABB3.js";
 
 
+/**
+ *
+ * @param {AABB3} expected
+ * @param {AABB3} actual
+ * @param {number} [numDigits]
+ */
 function compareBounds(expected, actual, numDigits = 10) {
     expect(actual.x0).toBeCloseTo(expected.x0, numDigits);
     expect(actual.y0).toBeCloseTo(expected.y0, numDigits);
@@ -225,3 +231,27 @@ test("getExtentsZ", () => {
     expect(new AABB3(0, 0, 0, 0, 0, 1).getExtentsZ()).toBeCloseTo(1);
     expect(new AABB3(0, 0, -1, 0, 0, 1).getExtentsZ()).toBeCloseTo(2);
 });
+
+test("setBoundsUnordered", () => {
+    const aabb = new AABB3();
+
+    aabb.setBoundsUnordered(1, 2, 3, -5, -7, -11);
+
+    compareBounds(aabb, new AABB3(-5, -7, -11, 1,2,3));
+
+    aabb.setBoundsUnordered(-5, -7, -11, 1, 2, 3);
+
+    compareBounds(aabb, new AABB3(-5, -7, -11, 1,2,3));
+
+    aabb.setBoundsUnordered(1, -7, -11, -5, 2, 3);
+
+    compareBounds(aabb, new AABB3(-5, -7, -11, 1,2,3));
+
+    aabb.setBoundsUnordered(-5, 2, -11, 1, -7, 3);
+
+    compareBounds(aabb, new AABB3(-5, -7, -11, 1,2,3));
+
+    aabb.setBoundsUnordered(-5, -7, 3, 1, 2, -11);
+
+    compareBounds(aabb, new AABB3(-5, -7, -11, 1,2,3));
+});

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

@@ -2,11 +2,11 @@ import { aabb3_build_corners } from "./aabb3_build_corners.js";
 import { aabb_build_frustum } from "./aabb3_build_frustum.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 { plane3_compute_convex_3_plane_intersection } from "../plane/plane3_compute_convex_3_plane_intersection.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";
+import { plane3_compute_line_segment_intersection } from "../plane/plane3_compute_line_segment_intersection.js";
 
 /**
  * Common piece of continuous memory for better cache coherence
@@ -205,7 +205,7 @@ export function aabb3_detailed_volume_intersection(
             const nz = planes[plane_address + 2];
             const c = planes[plane_address + 3];
 
-            const edge_intersects = plane3_computeLineSegmentIntersection(
+            const edge_intersects = plane3_compute_line_segment_intersection(
                 scratch_v3_array, 0,
                 corner_0_x, corner_0_y, corner_0_z,
                 corner_1_x, corner_1_y, corner_1_z,
@@ -256,7 +256,7 @@ export function aabb3_detailed_volume_intersection(
             const next_orthogonal_plane_index = (frustum_plane_index + 2) % 4;
             const cp_1 = next_orthogonal_plane_index * 4;
 
-            const intersection_exists = plane_computeConvex3PlaneIntersection(
+            const intersection_exists = plane3_compute_convex_3_plane_intersection(
                 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],

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

@@ -3,9 +3,9 @@ import { plane3_projectPoint } from "../plane/plane3_projectPoint.js";
 import { ray_computeNearestPointToPoint } from "../ray/ray_computeNearestPointToPoint.js";
 import { v3_distance_above_plane } from "../../v3_distance_above_plane.js";
 import {
-    plane_three_computeConvex3PlaneIntersection
-} from "../plane/plane_three_compute_convex3_plane_intersection.js";
-import { computePlanePlaneIntersection } from "../plane/computePlanePlaneIntersection.js";
+    plane3_three_compute_convex_3_plane_intersection
+} from "../plane/plane3_three_compute_convex_3_plane_intersection.js";
+import { plane3_compute_plane_intersection } from "../plane/plane3_compute_plane_intersection.js";
 
 /**
  *
@@ -82,7 +82,7 @@ export function frustum3_computeNearestPointToPoint(result, planes, target_x, ta
         const plane_0 = planes[plane_0_index];
         const plane_1 = planes[plane_1_index];
 
-        const intersection_exists = computePlanePlaneIntersection(plane_0, plane_1, scratch_v3_0, scratch_v3_1);
+        const intersection_exists = plane3_compute_plane_intersection(plane_0, plane_1, scratch_v3_0, scratch_v3_1);
 
         if (!intersection_exists) {
             throw new Error('Planes are parallel and do not intersect, likely an invalid frustum');
@@ -103,7 +103,7 @@ 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(scratch_v3_array, 0, plane_0, plane_1, plane_2);
+        plane3_three_compute_convex_3_plane_intersection(scratch_v3_array, 0, plane_0, plane_1, plane_2);
 
         result.readFromArray(scratch_v3_array, 0)
     }

package/src/core/geom/3d/matrix/m4_make_translation.js

@@ -1,4 +1,4 @@
-import { array_copy } from "../../../collection/array/copyArray.js";
+import { array_copy } from "../../../collection/array/array_copy.js";
 import { MATRIX_4_IDENTITY } from "./MATRIX_4_IDENTITY.js";
 
 /**

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

@@ -2,7 +2,7 @@ import { v3_distance_above_plane } from "../../v3_distance_above_plane.js";
 import { EPSILON } from "../../../math/EPSILON.js";
 
 /**
- *
+ * Checks if point lies in a volume bound by a number of planes, such a camera frustum
  * @param {number} x
  * @param {number} y
  * @param {number} z

package/src/core/geom/3d/plane/lerp_planes_to_array.js

@@ -48,4 +48,6 @@ function lerp_planes_to_array(
     const n_z = a_normal_z * scale_0 + b_normal_z * scale_1;
 
     //compute R
+
+    throw new Error("Not Implemented");
 }

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

@@ -23,7 +23,7 @@ import { v3_dot } from "../../v3_dot.js";
  * @param {number} c_constant
  * @returns {boolean} true if planes intersect, false otherwise
  */
-export function plane_computeConvex3PlaneIntersection(
+export function plane3_compute_convex_3_plane_intersection(
     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,

package/src/core/geom/3d/plane/{plane3_computeLineSegmentIntersection.js → plane3_compute_line_segment_intersection.js}

@@ -16,7 +16,7 @@ import { v3_dot } from "../../v3_dot.js";
  * @param {number} dist
  * @returns {boolean}
  */
-export function plane3_computeLineSegmentIntersection(
+export function plane3_compute_line_segment_intersection(
     result, result_offset,
     x0, y0, z0,
     x1, y1, z1,