@woosh/meep-engine 2.163.11 → 2.165.0

package/src/core/geom/3d/atlas/segment/atlas_segment_charts_atomic.js

@@ -0,0 +1,199 @@
+import { IndexedFloatMinHeap } from "../../../../collection/heap/IndexedFloatMinHeap.js";
+import { NULL_POINTER } from "../../topology/struct/binary/BinaryTopology.js";
+import { ATLAS_SEGMENT_DEFAULTS } from "./atlas_segment_charts.js";
+
+// These mirror atlas_segment_charts (the face-granular twin); kept local so the
+// two segmenters stay monomorphic.
+const REJECT = Infinity;
+const NORMAL_DEVIATION_REJECT = 0.707;
+const STALE_EPSILON = 1e-6;
+
+/**
+ * Region-atomic chart segmentation (xatlas grows whole coplanar regions as
+ * units). Identical greedy structure and cost to {@link atlas_segment_charts},
+ * but the growth nodes are planar regions from {@link atlas_build_region_graph}
+ * rather than individual triangles: a chart absorbs an entire region at a time.
+ * This keeps coplanar faces together (no seam through a flat surface) and is
+ * far cheaper on flat-heavy meshes (the heap holds regions, not triangles).
+ *
+ * Cost = `normalDeviationWeight·N + normalSeamWeight·NS + roundnessWeight·R`,
+ * with the same 73-degree hard reject and optional area/boundary caps. The
+ * candidate queue uses the same lazy re-evaluation. Deterministic.
+ *
+ * @param {RegionGraph} region_graph from atlas_build_region_graph
+ * @param {Uint32Array} region_of_face face -> region id (NULL_POINTER if unallocated)
+ * @param {object} [options] overrides of ATLAS_SEGMENT_DEFAULTS
+ * @returns {{face_chart: Int32Array, chart_count: number}}
+ */
+export function atlas_segment_charts_atomic(region_graph, region_of_face, options = {}) {
+    const opt = { ...ATLAS_SEGMENT_DEFAULTS, ...options };
+    const rg = region_graph;
+    const RC = rg.region_count;
+
+    const region_chart = new Int32Array(RC).fill(-1);
+    const region_cost = new Float32Array(RC);
+    const heap = new IndexedFloatMinHeap(Math.max(1, RC));
+
+    let chart_id = 0;
+    let chart_area = 0;
+    let chart_boundary = 0;
+    let accum_x = 0, accum_y = 0, accum_z = 0;
+
+    const cn = new Float32Array(3);
+    let out_area = 0;
+    let out_boundary = 0;
+
+    /**
+     * Normalize the chart's running area-weighted normal accumulator into `cn`.
+     */
+    function chart_unit_normal() {
+        const len = Math.sqrt(accum_x * accum_x + accum_y * accum_y + accum_z * accum_z) || 1;
+        cn[0] = accum_x / len;
+        cn[1] = accum_y / len;
+        cn[2] = accum_z / len;
+    }
+
+    /**
+     * Cost of adding region g to the current chart, or REJECT. Side effect: sets
+     * out_area / out_boundary for the caller to commit.
+     * @param {number} g region id
+     * @returns {number}
+     */
+    function evaluate(g) {
+        const gx = rg.region_normal[g * 3];
+        const gy = rg.region_normal[g * 3 + 1];
+        const gz = rg.region_normal[g * 3 + 2];
+        const glen = Math.sqrt(gx * gx + gy * gy + gz * gz) || 1;
+
+        chart_unit_normal();
+        const dot = (cn[0] * gx + cn[1] * gy + cn[2] * gz) / glen;
+        const N = Math.min(1 - dot, 1);
+        if (N >= NORMAL_DEVIATION_REJECT) {
+            return REJECT;
+        }
+
+        const new_area = chart_area + rg.region_area[g];
+        if (opt.maxChartArea > 0 && new_area > opt.maxChartArea) {
+            return REJECT;
+        }
+
+        let shared = 0;
+        let seam = 0;
+        const start = rg.offsets[g];
+        const end = rg.offsets[g + 1];
+        for (let k = start; k < end; k++) {
+            if (region_chart[rg.adj[k]] === chart_id) {
+                shared += rg.adj_shared[k];
+                seam += rg.adj_seam[k];
+            }
+        }
+
+        const new_boundary = chart_boundary + rg.region_boundary[g] - 2 * shared;
+        if (opt.maxBoundaryLength > 0 && new_boundary > opt.maxBoundaryLength) {
+            return REJECT;
+        }
+
+        const NS = shared > 0 ? seam / shared : 0;
+
+        let R = 0;
+        if (chart_area > 0 && chart_boundary > 0 && new_boundary > 0) {
+            const old_ratio = (chart_boundary * chart_boundary) / chart_area;
+            const new_ratio = (new_boundary * new_boundary) / new_area;
+            R = 1 - old_ratio / new_ratio;
+        }
+
+        out_area = new_area;
+        out_boundary = new_boundary;
+
+        return opt.normalDeviationWeight * N + opt.normalSeamWeight * NS + opt.roundnessWeight * R;
+    }
+
+    /**
+     * (Re-)evaluate and (re-)queue every unallocated region adjacent to r in the
+     * region graph, caching each candidate's cost in `region_cost`.
+     * @param {number} r region id just committed to the current chart
+     */
+    function push_neighbours(r) {
+        const start = rg.offsets[r];
+        const end = rg.offsets[r + 1];
+        for (let k = start; k < end; k++) {
+            const h = rg.adj[k];
+            if (region_chart[h] === -1) {
+                const c = evaluate(h);
+                if (c !== REJECT) {
+                    if (heap.contains(h)) {
+                        heap.update(h, c);
+                    } else {
+                        heap.insert(h, c);
+                    }
+                    region_cost[h] = c;
+                }
+            }
+        }
+    }
+
+    let chart_count = 0;
+
+    for (let seed = 0; seed < RC; seed++) {
+        if (region_chart[seed] !== -1) {
+            continue;
+        }
+
+        chart_id = chart_count;
+        chart_count++;
+        heap.clear();
+
+        region_chart[seed] = chart_id;
+        accum_x = rg.region_normal[seed * 3];
+        accum_y = rg.region_normal[seed * 3 + 1];
+        accum_z = rg.region_normal[seed * 3 + 2];
+        chart_area = rg.region_area[seed];
+        chart_boundary = rg.region_boundary[seed];
+
+        push_neighbours(seed);
+
+        for (;;) {
+            const g = heap.pop_min();
+            if (g === -1) {
+                break;
+            }
+            if (region_chart[g] !== -1) {
+                continue;
+            }
+
+            const stored = region_cost[g];
+            const fresh = evaluate(g);
+            if (fresh === REJECT) {
+                continue;
+            }
+            if (Math.abs(fresh - stored) > STALE_EPSILON) {
+                region_cost[g] = fresh;
+                heap.insert(g, fresh);
+                continue;
+            }
+            if (fresh > opt.maxCost) {
+                break;
+            }
+
+            region_chart[g] = chart_id;
+            chart_area = out_area;
+            chart_boundary = out_boundary;
+            accum_x += rg.region_normal[g * 3];
+            accum_y += rg.region_normal[g * 3 + 1];
+            accum_z += rg.region_normal[g * 3 + 2];
+
+            push_neighbours(g);
+        }
+    }
+
+    const face_count = region_of_face.length;
+    const face_chart = new Int32Array(face_count).fill(-1);
+    for (let f = 0; f < face_count; f++) {
+        const r = region_of_face[f];
+        if (r !== NULL_POINTER) {
+            face_chart[f] = region_chart[r];
+        }
+    }
+
+    return { face_chart, chart_count };
+}

package/src/core/geom/3d/capsule/capsule_intersects_aabb3_closed.d.ts

@@ -9,7 +9,7 @@
  *     overlap  ⟺  distanceSqr(segment, AABB) ≤ r²
  *
  * The closest point on the segment to the box is located in O(1) by
- * {@link line3_compute_segment_nearest_point_to_aabb3_t} (convex
+ * {@link line3_compute_segment_closest_point_to_aabb3_t} (convex
  * piecewise-quadratic minimiser); this then compares that closest distance to
  * `r²`. {@link capsule_intersects_aabb3_iterative} is the convex-bisection
  * sibling (simpler, but ~50 refinement steps). A degenerate capsule

package/src/core/geom/3d/capsule/capsule_intersects_aabb3_closed.js

@@ -1,6 +1,6 @@
 import { clamp } from "../../../math/clamp.js";
 import { v3_distance_sqr } from "../../vec3/v3_distance_sqr.js";
-import { line3_compute_segment_nearest_point_to_aabb3_t } from "../line/line3_compute_segment_nearest_point_to_aabb3_t.js";
+import { line3_compute_segment_closest_point_to_aabb3_t } from "../line/line3_compute_segment_closest_point_to_aabb3_t.js";
 
 /**
  * Test whether an oriented capsule overlaps an axis-aligned box — exact,
@@ -13,7 +13,7 @@ import { line3_compute_segment_nearest_point_to_aabb3_t } from "../line/line3_co
  *     overlap  ⟺  distanceSqr(segment, AABB) ≤ r²
  *
  * The closest point on the segment to the box is located in O(1) by
- * {@link line3_compute_segment_nearest_point_to_aabb3_t} (convex
+ * {@link line3_compute_segment_closest_point_to_aabb3_t} (convex
  * piecewise-quadratic minimiser); this then compares that closest distance to
  * `r²`. {@link capsule_intersects_aabb3_iterative} is the convex-bisection
  * sibling (simpler, but ~50 refinement steps). A degenerate capsule
@@ -47,7 +47,7 @@ export function capsule_intersects_aabb3_closed(
     box_x0, box_y0, box_z0,
     box_x1, box_y1, box_z1
 ) {
-    const t = line3_compute_segment_nearest_point_to_aabb3_t(
+    const t = line3_compute_segment_closest_point_to_aabb3_t(
         p0_x, p0_y, p0_z,
         p1_x, p1_y, p1_z,
         box_x0, box_y0, box_z0,

package/src/core/geom/3d/circle3_compute_bounding_box.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Compute 3d bounds of a circle in 3d space
+ * NOTE: based on https://stackoverflow.com/questions/2592011/bounding-boxes-for-circle-and-arcs-in-3d
+ * @param {AABB3} result
+ * @param {number} centerX
+ * @param {number} centerY
+ * @param {number} centerZ
+ * @param {number} normalX orientation of the circle
+ * @param {number} normalY orientation of the circle
+ * @param {number} normalZ orientation of the circle
+ * @param {number} radius
+ */
+export function circle3_compute_bounding_box(result: AABB3, centerX: number, centerY: number, centerZ: number, normalX: number, normalY: number, normalZ: number, radius: number): void;
+//# sourceMappingURL=circle3_compute_bounding_box.d.ts.map

package/src/core/geom/3d/circle3_compute_bounding_box.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"circle3_compute_bounding_box.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/3d/circle3_compute_bounding_box.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,qEARW,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,UACN,MAAM,QAsBhB"}

package/src/core/geom/3d/circle3_compute_bounding_box.js

@@ -0,0 +1,35 @@
+import { v3_angle } from "../vec3/v3_angle.js";
+
+/**
+ * Compute 3d bounds of a circle in 3d space
+ * NOTE: based on https://stackoverflow.com/questions/2592011/bounding-boxes-for-circle-and-arcs-in-3d
+ * @param {AABB3} result
+ * @param {number} centerX
+ * @param {number} centerY
+ * @param {number} centerZ
+ * @param {number} normalX orientation of the circle
+ * @param {number} normalY orientation of the circle
+ * @param {number} normalZ orientation of the circle
+ * @param {number} radius
+ */
+export function circle3_compute_bounding_box(
+    result,
+    centerX, centerY, centerZ,
+    normalX, normalY, normalZ,
+    radius
+) {
+
+    const ax = v3_angle(normalX, normalY, normalZ, 1, 0, 0);
+    const ay = v3_angle(normalX, normalY, normalZ, 0, 1, 0);
+    const az = v3_angle(normalX, normalY, normalZ, 0, 0, 1);
+
+    const rX = Math.sin(ax) * radius;
+    const rY = Math.sin(ay) * radius;
+    const rZ = Math.sin(az) * radius;
+
+    result.setBounds(
+        centerX - rX, centerY - rY, centerZ - rZ,
+        centerX + rX, centerY + rY, centerZ + rZ
+    );
+
+}

package/src/core/geom/3d/compute_circle_bounding_box.d.ts

@@ -1,14 +1,7 @@
 /**
- * Compute 3d bounds of a circle in 3d space
- * NOTE: based on https://stackoverflow.com/questions/2592011/bounding-boxes-for-circle-and-arcs-in-3d
- * @param {AABB3} result
- * @param {number} centerX
- * @param {number} centerY
- * @param {number} centerZ
- * @param {number} normalX orientation of the circle
- * @param {number} normalY orientation of the circle
- * @param {number} normalZ orientation of the circle
- * @param {number} radius
+ * @deprecated Renamed to {@link circle3_compute_bounding_box}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
  */
-export function compute_circle_bounding_box(result: AABB3, centerX: number, centerY: number, centerZ: number, normalX: number, normalY: number, normalZ: number, radius: number): void;
+export const compute_circle_bounding_box: typeof circle3_compute_bounding_box;
+import { circle3_compute_bounding_box } from "./circle3_compute_bounding_box.js";
 //# sourceMappingURL=compute_circle_bounding_box.d.ts.map

package/src/core/geom/3d/compute_circle_bounding_box.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compute_circle_bounding_box.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/3d/compute_circle_bounding_box.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,oEARW,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,UACN,MAAM,QAsBhB"}
+{"version":3,"file":"compute_circle_bounding_box.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/3d/compute_circle_bounding_box.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,8EAAwE;6CAN3B,mCAAmC"}

package/src/core/geom/3d/compute_circle_bounding_box.js

@@ -1,35 +1,7 @@
-import { v3_angle_between } from "../vec3/v3_angle_between.js";
-
-/**
- * Compute 3d bounds of a circle in 3d space
- * NOTE: based on https://stackoverflow.com/questions/2592011/bounding-boxes-for-circle-and-arcs-in-3d
- * @param {AABB3} result
- * @param {number} centerX
- * @param {number} centerY
- * @param {number} centerZ
- * @param {number} normalX orientation of the circle
- * @param {number} normalY orientation of the circle
- * @param {number} normalZ orientation of the circle
- * @param {number} radius
- */
-export function compute_circle_bounding_box(
-    result,
-    centerX, centerY, centerZ,
-    normalX, normalY, normalZ,
-    radius
-) {
-
-    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;
-    const rZ = Math.sin(az) * radius;
-
-    result.setBounds(
-        centerX - rX, centerY - rY, centerZ - rZ,
-        centerX + rX, centerY + rY, centerZ + rZ
-    );
-
-}
+import { circle3_compute_bounding_box } from "./circle3_compute_bounding_box.js";
+
+/**
+ * @deprecated Renamed to {@link circle3_compute_bounding_box}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
+ */
+export const compute_circle_bounding_box = circle3_compute_bounding_box;

package/src/core/geom/3d/cone/computeConeBoundingBox.d.ts

@@ -1,14 +1,7 @@
 /**
- * NOTE: used stackoverflow answer as a basis for circle part: https://stackoverflow.com/questions/2592011/bounding-boxes-for-circle-and-arcs-in-3d
- * @param {number[]|ArrayLike<number>|Float32Array} result
- * @param {number} originX
- * @param {number} originY
- * @param {number} originZ
- * @param {number} directionX
- * @param {number} directionY
- * @param {number} directionZ
- * @param {number} angle in Radians
- * @param {number} length
+ * @deprecated Renamed to {@link cone_compute_bounding_box}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
  */
-export function computeConeBoundingBox(result: number[] | ArrayLike<number> | Float32Array, originX: number, originY: number, originZ: number, directionX: number, directionY: number, directionZ: number, angle: number, length: number): void;
+export const computeConeBoundingBox: typeof cone_compute_bounding_box;
+import { cone_compute_bounding_box } from "./cone_compute_bounding_box.js";
 //# sourceMappingURL=computeConeBoundingBox.d.ts.map

package/src/core/geom/3d/cone/computeConeBoundingBox.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"computeConeBoundingBox.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/cone/computeConeBoundingBox.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;GAWG;AACH,+CAVW,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,YAAY,WACvC,MAAM,WACN,MAAM,WACN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,SACN,MAAM,UACN,MAAM,QA2ChB"}
+{"version":3,"file":"computeConeBoundingBox.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/cone/computeConeBoundingBox.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,sEAAgE;0CANtB,gCAAgC"}

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

@@ -1,58 +1,7 @@
-import { max2 } from "../../../math/max2.js";
-import { min2 } from "../../../math/min2.js";
-import { v3_angle_between } from "../../vec3/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
- * @param {number[]|ArrayLike<number>|Float32Array} result
- * @param {number} originX
- * @param {number} originY
- * @param {number} originZ
- * @param {number} directionX
- * @param {number} directionY
- * @param {number} directionZ
- * @param {number} angle in Radians
- * @param {number} length
- */
-export function computeConeBoundingBox(
-    result,
-    originX, originY, originZ,
-    directionX, directionY, directionZ,
-    angle,
-    length
-) {
-
-    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);
-
-    //compute cone base center
-    const centerX = originX + directionX * length;
-    const centerY = originY + directionY * length;
-    const centerZ = originZ + directionZ * length;
-
-    const rX = Math.sin(ax) * radius;
-    const rY = Math.sin(ay) * radius;
-    const rZ = Math.sin(az) * radius;
-
-    //compute cone base bounds
-    const cx0 = centerX - rX;
-    const cy0 = centerY - rY;
-    const cz0 = centerZ - rZ;
-
-    const cx1 = centerX + rX;
-    const cy1 = centerY + rY;
-    const cz1 = centerZ + rZ;
-
-    //combine bounds of the origin and base of the cone
-    result[0] = min2(originX, cx0);
-    result[1] = min2(originY, cy0);
-    result[2] = min2(originZ, cz0);
-
-    result[3] = max2(originX, cx1);
-    result[4] = max2(originY, cy1);
-    result[5] = max2(originZ, cz1);
-}
+import { cone_compute_bounding_box } from "./cone_compute_bounding_box.js";
+
+/**
+ * @deprecated Renamed to {@link cone_compute_bounding_box}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
+ */
+export const computeConeBoundingBox = cone_compute_bounding_box;

package/src/core/geom/3d/cone/computeConePlaneSide.d.ts

@@ -1,19 +1,7 @@
 /**
- * 2,0,or -2; 2: above, -2 : below, 0 : intersects plane
- * NOTE: used an article by Bart Wronski https://bartwronski.com/2017/04/13/cull-that-cone/
- * @param {number} plane_normal_x
- * @param {number} plane_normal_y
- * @param {number} plane_normal_z
- * @param {number} plane_constant
- * @param {number} originX
- * @param {number} originY
- * @param {number} originZ
- * @param {number} directionX
- * @param {number} directionY
- * @param {number} directionZ
- * @param {number} angle
- * @param {number} length
- * @returns {number}
+ * @deprecated Renamed to {@link cone_compute_plane_side}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
  */
-export function computeConePlaneSide(plane_normal_x: number, plane_normal_y: number, plane_normal_z: number, plane_constant: number, originX: number, originY: number, originZ: number, directionX: number, directionY: number, directionZ: number, angle: number, length: number): number;
+export const computeConePlaneSide: typeof cone_compute_plane_side;
+import { cone_compute_plane_side } from "./cone_compute_plane_side.js";
 //# sourceMappingURL=computeConePlaneSide.d.ts.map

package/src/core/geom/3d/cone/computeConePlaneSide.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"computeConePlaneSide.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/cone/computeConePlaneSide.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;GAgBG;AACH,qDAdW,MAAM,kBACN,MAAM,kBACN,MAAM,kBACN,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,SACN,MAAM,UACN,MAAM,GACJ,MAAM,CAgElB"}
+{"version":3,"file":"computeConePlaneSide.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/cone/computeConePlaneSide.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,kEAA4D;wCANpB,8BAA8B"}

package/src/core/geom/3d/cone/computeConePlaneSide.js

@@ -1,86 +1,7 @@
-import { v4_dot } from "../../vec4/v4_dot.js";
-import Vector3 from "../../Vector3.js";
-
-const V1 = new Vector3();
-const V2 = new Vector3();
-
-/**
- * 2,0,or -2; 2: above, -2 : below, 0 : intersects plane
- * NOTE: used an article by Bart Wronski https://bartwronski.com/2017/04/13/cull-that-cone/
- * @param {number} plane_normal_x
- * @param {number} plane_normal_y
- * @param {number} plane_normal_z
- * @param {number} plane_constant
- * @param {number} originX
- * @param {number} originY
- * @param {number} originZ
- * @param {number} directionX
- * @param {number} directionY
- * @param {number} directionZ
- * @param {number} angle
- * @param {number} length
- * @returns {number}
- */
-export function computeConePlaneSide(
-    plane_normal_x, plane_normal_y, plane_normal_z,
-    plane_constant,
-    originX, originY, originZ,
-    directionX, directionY, directionZ,
-    angle,
-    length
-) {
-
-    /*
-    ORIGINAL HLSL:
-    bool TestConeVsPlane(in float3 origin, in float3 forward, in float size, in float angle, in float4 testPlane)
-    {
-        const float3 V1 = cross(testPlane.xyz, forward);
-        const float3 V2 = cross(V1, forward);
-
-        const float3 capRimPoint =  origin +
-                                    size * cos(angle) * forward +
-                                    size * sin(angle) * V2;
-
-        return dot(float4(capRimPoint, 1.0f), testPlane) >= 0.0f || dot(float4(origin, 1.0f), testPlane) >= 0.0f;
-    }
-     */
-
-    V1._crossVectors(plane_normal_x, plane_normal_y, plane_normal_z, directionX, directionY, directionZ);
-    V2._crossVectors(V1.x, V1.y, V1.z, directionX, directionY, directionZ);
-
-    const scaled_cos = length * Math.cos(angle);
-    const scaled_sin = length * Math.sin(angle);
-
-    // compute cap rim point (closest point to the plane on the wide side of the cone)
-    V1.set(
-        originX + scaled_cos * directionX + scaled_sin * V2.x,
-        originY + scaled_cos * directionY + scaled_sin * V2.y,
-        originZ + scaled_cos * directionZ + scaled_sin * V2.z
-    );
-
-    const rim_point_side = v4_dot(
-        V1.x, V1.y, V1.z, 1,
-        plane_normal_x, plane_normal_y, plane_normal_z, plane_constant
-    );
-
-    const origin_point_side = v4_dot(
-        originX, originY, originZ, 1,
-        plane_normal_x, plane_normal_y, plane_normal_z, plane_constant
-    );
-
-    let result = 0;
-
-    if (rim_point_side >= 0) {
-        result += 1;
-    } else {
-        result -= 1;
-    }
-
-    if (origin_point_side >= 0) {
-        result += 1;
-    } else {
-        result -= 1;
-    }
-
-    return result;
-}
+import { cone_compute_plane_side } from "./cone_compute_plane_side.js";
+
+/**
+ * @deprecated Renamed to {@link cone_compute_plane_side}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
+ */
+export const computeConePlaneSide = cone_compute_plane_side;

package/src/core/geom/3d/cone/compute_bounding_cone_of_2_cones.d.ts

@@ -1,8 +1,7 @@
 /**
- *
- * @param {ConicRay} result
- * @param {ConicRay} a
- * @param {ConicRay} b
+ * @deprecated Renamed to {@link cone_compute_bounding_of_2_cones}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
  */
-export function compute_bounding_cone_of_2_cones(result: ConicRay, a: ConicRay, b: ConicRay): void;
+export const compute_bounding_cone_of_2_cones: typeof cone_compute_bounding_of_2_cones;
+import { cone_compute_bounding_of_2_cones } from "./cone_compute_bounding_of_2_cones.js";
 //# sourceMappingURL=compute_bounding_cone_of_2_cones.d.ts.map

package/src/core/geom/3d/cone/compute_bounding_cone_of_2_cones.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compute_bounding_cone_of_2_cones.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/cone/compute_bounding_cone_of_2_cones.js"],"names":[],"mappings":"AAiBA;;;;;GAKG;AACH,mGAyEC"}
+{"version":3,"file":"compute_bounding_cone_of_2_cones.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/cone/compute_bounding_cone_of_2_cones.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,uFAAiF;iDANhC,uCAAuC"}