@woosh/meep-engine 2.163.10 → 2.164.0

package/src/core/geom/3d/triangle/tri3_ray_intersection.js

@@ -0,0 +1,160 @@
+import { v3_dot } from "../../vec3/v3_dot.js";
+import { assert } from "../../../assert.js";
+
+/**
+ * NOTE: adapted from http://www.geometrictools.com/GTEngine/Include/Mathematics/GteIntrRay3Triangle3.h
+ * @source https://en.wikipedia.org/wiki/M%C3%B6ller%E2%80%93Trumbore_intersection_algorithm (Möller and Trumbore, « Fast, Minimum Storage Ray-Triangle Intersection », Journal of Graphics Tools, vol. 2,‎ 1997, p. 21–28)
+ * @param {SurfacePoint3} result
+ * @param {number} origin_x
+ * @param {number} origin_y
+ * @param {number} origin_z
+ * @param {number} direction_x
+ * @param {number} direction_y
+ * @param {number} direction_z
+ * @param {number} ax
+ * @param {number} ay
+ * @param {number} az
+ * @param {number} bx
+ * @param {number} by
+ * @param {number} bz
+ * @param {number} cx
+ * @param {number} cy
+ * @param {number} cz
+ * @returns {boolean}
+ */
+export function tri3_ray_intersection(
+    result,
+    origin_x, origin_y, origin_z,
+    direction_x, direction_y, direction_z,
+    ax, ay, az,
+    bx, by, bz,
+    cx, cy, cz
+) {
+    assert.isNumber(ax, 'ax');
+    assert.isNumber(ay, 'ay');
+    assert.isNumber(az, 'az');
+
+    assert.isNumber(bx, 'bx');
+    assert.isNumber(by, 'by');
+    assert.isNumber(bz, 'bz');
+
+    assert.isNumber(cx, 'cx');
+    assert.isNumber(cy, 'cy');
+    assert.isNumber(cz, 'cz');
+
+    // nan checks
+    assert.notNaN(ax, 'ax');
+    assert.notNaN(ay, 'ay');
+    assert.notNaN(az, 'az');
+
+    assert.notNaN(bx, 'bx');
+    assert.notNaN(by, 'by');
+    assert.notNaN(bz, 'bz');
+
+    assert.notNaN(cx, 'cx');
+    assert.notNaN(cy, 'cy');
+    assert.notNaN(cz, 'cz');
+
+    // finate number check
+    assert.isFinite(ax, 'ax');
+    assert.isFinite(ay, 'ay');
+    assert.isFinite(az, 'az');
+
+    assert.isFinite(bx, 'bx');
+    assert.isFinite(by, 'by');
+    assert.isFinite(bz, 'bz');
+
+    assert.isFinite(cx, 'cx');
+    assert.isFinite(cy, 'cy');
+    assert.isFinite(cz, 'cz');
+
+
+    // edge1 = a - b
+    const edge1_x = bx - ax;
+    const edge1_y = by - ay;
+    const edge1_z = bz - az;
+
+    // edge2 = c - a
+    const edge2_x = cx - ax;
+    const edge2_y = cy - ay;
+    const edge2_z = cz - az;
+
+    // Compute triangle normal
+
+    // normal = edge1 x edge2
+    const normal_x = edge1_y * edge2_z - edge1_z * edge2_y;
+    const normal_y = edge1_z * edge2_x - edge1_x * edge2_z;
+    const normal_z = edge1_x * edge2_y - edge1_y * edge2_x
+
+    let DdN = v3_dot(direction_x, direction_y, direction_z, normal_x, normal_y, normal_z);
+    let sign = 1;
+
+    if (DdN === 0) {
+        // ray and the triangle normal are orthogonal, means that the ray can not pass penetrate triangle
+        return false;
+    } else if (DdN < 0) {
+        sign = -1;
+        DdN = -DdN;
+    }
+
+    // diff = origin - a
+    const diff_x = origin_x - ax;
+    const diff_y = origin_y - ay;
+    const diff_z = origin_z - az;
+
+    // edge3 = diff x edge2
+    const edge3_x = diff_y * edge2_z - diff_z * edge2_y;
+    const edge3_y = diff_z * edge2_x - diff_x * edge2_z;
+    const edge3_z = diff_x * edge2_y - diff_y * edge2_x;
+
+    // DdQxE2 = sign * ( direction . edge3)
+    const DdQxE2 = sign * v3_dot(direction_x, direction_y, direction_z, edge3_x, edge3_y, edge3_z);
+
+    if (DdQxE2 < 0) {
+        // b1 < 0, no intersection
+        return false;
+    }
+
+    const edge4_x = edge1_y * diff_z - edge1_z * diff_y;
+    const edge4_y = edge1_z * diff_x - edge1_x * diff_z;
+    const edge4_z = edge1_x * diff_y - edge1_y * diff_x;
+
+    const DdE1xQ = sign * v3_dot(direction_x, direction_y, direction_z, edge4_x, edge4_y, edge4_z);
+
+    if (DdE1xQ < 0) {
+        // b2 < 0, no intersection
+        return false;
+    }
+
+    if (DdQxE2 + DdE1xQ > DdN) {
+        // b1+b2 > 1, no intersection
+        return false;
+    }
+
+    // Line intersects triangle, check if ray does.
+    const QdN = -sign * v3_dot(diff_x, diff_y, diff_z, normal_x, normal_y, normal_z);
+
+    if (QdN < 0) {
+        // t < 0, no intersection
+        return false;
+
+    }
+
+    // Ray intersects triangle.
+    const t = QdN / DdN;
+
+    result.normal.set(
+        normal_x,
+        normal_y,
+        normal_z
+    );
+
+    result.position.set(
+        direction_x * t + origin_x,
+        direction_y * t + origin_y,
+        direction_z * t + origin_z,
+    );
+
+    return true;
+}
+

package/src/core/geom/3d/triangle/tri3_ray_intersection_barycentric.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Compute barycentric coordinates for triangle intersection
+ * NOTE:  most of the code is inlined for speed to avoid allocation and function calls
+ * @see https://github.com/erich666/jgt-code/blob/master/Volume_02/Number_1/Moller1997a/raytri.c
+ * @source https://en.wikipedia.org/wiki/M%C3%B6ller%E2%80%93Trumbore_intersection_algorithm (Möller and Trumbore, « Fast, Minimum Storage Ray-Triangle Intersection », Journal of Graphics Tools, vol. 2,‎ 1997, p. 21–28)
+ * @param {number[]} result [t,u,v, normal_x, normal_y, normal_z] will be written here
+ * @param {number} origin_x
+ * @param {number} origin_y
+ * @param {number} origin_z
+ * @param {number} direction_x
+ * @param {number} direction_y
+ * @param {number} direction_z
+ * @param {number} ax
+ * @param {number} ay
+ * @param {number} az
+ * @param {number} bx
+ * @param {number} by
+ * @param {number} bz
+ * @param {number} cx
+ * @param {number} cy
+ * @param {number} cz
+ * @returns {boolean}
+ */
+export function tri3_ray_intersection_barycentric(result: number[], origin_x: number, origin_y: number, origin_z: number, direction_x: number, direction_y: number, direction_z: number, ax: number, ay: number, az: number, bx: number, by: number, bz: number, cx: number, cy: number, cz: number): boolean;
+//# sourceMappingURL=tri3_ray_intersection_barycentric.d.ts.map

package/src/core/geom/3d/triangle/tri3_ray_intersection_barycentric.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tri3_ray_intersection_barycentric.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/tri3_ray_intersection_barycentric.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,0DAlBW,MAAM,EAAE,YACR,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,OAAO,CAqEnB"}

package/src/core/geom/3d/triangle/tri3_ray_intersection_barycentric.js

@@ -0,0 +1,96 @@
+import { assert } from "../../../assert.js";
+import { tri3_ray_intersection_barycentric_edge } from "./tri3_ray_intersection_barycentric_edge.js";
+
+/**
+ * Compute barycentric coordinates for triangle intersection
+ * NOTE:  most of the code is inlined for speed to avoid allocation and function calls
+ * @see https://github.com/erich666/jgt-code/blob/master/Volume_02/Number_1/Moller1997a/raytri.c
+ * @source https://en.wikipedia.org/wiki/M%C3%B6ller%E2%80%93Trumbore_intersection_algorithm (Möller and Trumbore, « Fast, Minimum Storage Ray-Triangle Intersection », Journal of Graphics Tools, vol. 2,‎ 1997, p. 21–28)
+ * @param {number[]} result [t,u,v, normal_x, normal_y, normal_z] will be written here
+ * @param {number} origin_x
+ * @param {number} origin_y
+ * @param {number} origin_z
+ * @param {number} direction_x
+ * @param {number} direction_y
+ * @param {number} direction_z
+ * @param {number} ax
+ * @param {number} ay
+ * @param {number} az
+ * @param {number} bx
+ * @param {number} by
+ * @param {number} bz
+ * @param {number} cx
+ * @param {number} cy
+ * @param {number} cz
+ * @returns {boolean}
+ */
+export function tri3_ray_intersection_barycentric(
+    result,
+    origin_x, origin_y, origin_z,
+    direction_x, direction_y, direction_z,
+    ax, ay, az,
+    bx, by, bz,
+    cx, cy, cz
+) {
+    assert.isNumber(ax, 'ax');
+    assert.isNumber(ay, 'ay');
+    assert.isNumber(az, 'az');
+
+    assert.isNumber(bx, 'bx');
+    assert.isNumber(by, 'by');
+    assert.isNumber(bz, 'bz');
+
+    assert.isNumber(cx, 'cx');
+    assert.isNumber(cy, 'cy');
+    assert.isNumber(cz, 'cz');
+
+    // nan checks
+    assert.notNaN(ax, 'ax');
+    assert.notNaN(ay, 'ay');
+    assert.notNaN(az, 'az');
+
+    assert.notNaN(bx, 'bx');
+    assert.notNaN(by, 'by');
+    assert.notNaN(bz, 'bz');
+
+    assert.notNaN(cx, 'cx');
+    assert.notNaN(cy, 'cy');
+    assert.notNaN(cz, 'cz');
+
+    // finate number check
+    assert.isFinite(ax, 'ax');
+    assert.isFinite(ay, 'ay');
+    assert.isFinite(az, 'az');
+
+    assert.isFinite(bx, 'bx');
+    assert.isFinite(by, 'by');
+    assert.isFinite(bz, 'bz');
+
+    assert.isFinite(cx, 'cx');
+    assert.isFinite(cy, 'cy');
+    assert.isFinite(cz, 'cz');
+
+
+    // find vectors for two edges sharing vert
+
+    // edge1 = a - b
+    const edge1_x = bx - ax;
+    const edge1_y = by - ay;
+    const edge1_z = bz - az;
+
+    // edge2 = c - a
+    const edge2_x = cx - ax;
+    const edge2_y = cy - ay;
+    const edge2_z = cz - az;
+
+    return tri3_ray_intersection_barycentric_edge(
+        result,
+        origin_x, origin_y, origin_z,
+        direction_x, direction_y, direction_z,
+        ax, ay, az,
+        edge1_x, edge1_y, edge1_z,
+        edge2_x, edge2_y, edge2_z
+    );
+}
+
+

package/src/core/geom/3d/triangle/tri3_ray_intersection_barycentric_edge.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Compute barycentric coordinates for triangle intersection
+ * Operates on edges, this is optimized for raytracing, as same edges are required to reconstruct various attributes later on
+ * NOTE:  most of the code is inlined for speed to avoid allocation and function calls
+ * @see https://github.com/erich666/jgt-code/blob/master/Volume_02/Number_1/Moller1997a/raytri.c
+ * @source https://en.wikipedia.org/wiki/M%C3%B6ller%E2%80%93Trumbore_intersection_algorithm (Möller and Trumbore, « Fast, Minimum Storage Ray-Triangle Intersection », Journal of Graphics Tools, vol. 2,‎ 1997, p. 21–28)
+ * @param {number[]} result
+ * @param {number} origin_x
+ * @param {number} origin_y
+ * @param {number} origin_z
+ * @param {number} direction_x
+ * @param {number} direction_y
+ * @param {number} direction_z
+ * @param {number} ax
+ * @param {number} ay
+ * @param {number} az
+ * @param {number} edge1_x
+ * @param {number} edge1_y
+ * @param {number} edge1_z
+ * @param {number} edge2_x
+ * @param {number} edge2_y
+ * @param {number} edge2_z
+ * @return {boolean}
+ */
+export function tri3_ray_intersection_barycentric_edge(result: number[], origin_x: number, origin_y: number, origin_z: number, direction_x: number, direction_y: number, direction_z: number, ax: number, ay: number, az: number, edge1_x: number, edge1_y: number, edge1_z: number, edge2_x: number, edge2_y: number, edge2_z: number): boolean;
+//# sourceMappingURL=tri3_ray_intersection_barycentric_edge.d.ts.map

package/src/core/geom/3d/triangle/tri3_ray_intersection_barycentric_edge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tri3_ray_intersection_barycentric_edge.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/tri3_ray_intersection_barycentric_edge.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,+DAlBW,MAAM,EAAE,YACR,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,GACL,OAAO,CAsElB"}

package/src/core/geom/3d/triangle/tri3_ray_intersection_barycentric_edge.js

@@ -0,0 +1,95 @@
+import { v3_dot } from "../../vec3/v3_dot.js";
+
+/**
+ * Compute barycentric coordinates for triangle intersection
+ * Operates on edges, this is optimized for raytracing, as same edges are required to reconstruct various attributes later on
+ * NOTE:  most of the code is inlined for speed to avoid allocation and function calls
+ * @see https://github.com/erich666/jgt-code/blob/master/Volume_02/Number_1/Moller1997a/raytri.c
+ * @source https://en.wikipedia.org/wiki/M%C3%B6ller%E2%80%93Trumbore_intersection_algorithm (Möller and Trumbore, « Fast, Minimum Storage Ray-Triangle Intersection », Journal of Graphics Tools, vol. 2,‎ 1997, p. 21–28)
+ * @param {number[]} result
+ * @param {number} origin_x
+ * @param {number} origin_y
+ * @param {number} origin_z
+ * @param {number} direction_x
+ * @param {number} direction_y
+ * @param {number} direction_z
+ * @param {number} ax
+ * @param {number} ay
+ * @param {number} az
+ * @param {number} edge1_x
+ * @param {number} edge1_y
+ * @param {number} edge1_z
+ * @param {number} edge2_x
+ * @param {number} edge2_y
+ * @param {number} edge2_z
+ * @return {boolean}
+ */
+export function tri3_ray_intersection_barycentric_edge(
+    result,
+    origin_x, origin_y, origin_z,
+    direction_x, direction_y, direction_z,
+    ax, ay, az,
+    edge1_x, edge1_y, edge1_z,
+    edge2_x, edge2_y, edge2_z
+) {
+
+    // begin calculating determinant - also used to calculate U parameter
+
+    // CROSS(pvec, dir, edge2)
+    const pvec_x = direction_y * edge2_z - direction_z * edge2_y;
+    const pvec_y = direction_z * edge2_x - direction_x * edge2_z;
+    const pvec_z = direction_x * edge2_y - direction_y * edge2_x;
+
+    //if determinant is near zero, ray lies in plane of triangle
+    const det = v3_dot(edge1_x, edge1_y, edge1_z, pvec_x, pvec_y, pvec_z);
+
+    if(det === 0){
+        // ray is parallel to the plane of the triange, no intersection possible
+        return false;
+    }
+
+    if (det <= 0) {
+        // back-face culling
+        // return false;
+    }
+
+    const inv_det = 1 / det;
+
+    // calculate distance from vert0 to ray origin (not really, but okay)
+    const tvec_x = origin_x - ax;
+    const tvec_y = origin_y - ay;
+    const tvec_z = origin_z - az;
+
+    // calculate u
+    const u = v3_dot(tvec_x, tvec_y, tvec_z, pvec_x, pvec_y, pvec_z)*inv_det;
+
+    if (u < 0 || u > 1) {
+        // outside of bounds of the triangle
+        return false;
+    }
+
+    // prepare to test V parameter
+    // CROSS(qvec, tvec, edge1)
+    const qvec_x = tvec_y * edge1_z - tvec_z * edge1_y;
+    const qvec_y = tvec_z * edge1_x - tvec_x * edge1_z;
+    const qvec_z = tvec_x * edge1_y - tvec_y * edge1_x;
+
+    // calculate V parameter
+    const v = v3_dot(direction_x, direction_y, direction_z, qvec_x, qvec_y, qvec_z)*inv_det;
+
+    if (v < 0 || u + v > 1) {
+        // out of bounds
+        return false;
+    }
+
+
+
+    // calculate t, scale parameter, ray intersects triangle
+    const t = v3_dot(edge2_x, edge2_y, edge2_z, qvec_x, qvec_y, qvec_z) * inv_det;
+
+    result[0] = t;
+    result[1] = u ;
+    result[2] = v ;
+
+    return true;
+}

package/src/core/geom/3d/triangle/tri3_ray_intersection_indexed.d.ts

@@ -0,0 +1,16 @@
+/**
+ *
+ * @param {number[]} result
+ * @param {number} origin_x
+ * @param {number} origin_y
+ * @param {number} origin_z
+ * @param {number} direction_x
+ * @param {number} direction_y
+ * @param {number} direction_z
+ * @param {number[]|ArrayLike<number>|Uint32Array} indices
+ * @param {number} triangle_index
+ * @param {number[]|Float32Array} positions
+ * @return {boolean}
+ */
+export function tri3_ray_intersection_indexed(result: number[], origin_x: number, origin_y: number, origin_z: number, direction_x: number, direction_y: number, direction_z: number, indices: number[] | ArrayLike<number> | Uint32Array, triangle_index: number, positions: number[] | Float32Array): boolean;
+//# sourceMappingURL=tri3_ray_intersection_indexed.d.ts.map

package/src/core/geom/3d/triangle/tri3_ray_intersection_indexed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tri3_ray_intersection_indexed.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/tri3_ray_intersection_indexed.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,sDAZW,MAAM,EAAE,YACR,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,WACN,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,WAAW,kBACtC,MAAM,aACN,MAAM,EAAE,GAAC,YAAY,GACpB,OAAO,CAwClB"}

package/src/core/geom/3d/triangle/tri3_ray_intersection_indexed.js

@@ -0,0 +1,55 @@
+import { tri3_ray_intersection_barycentric } from "./tri3_ray_intersection_barycentric.js";
+
+/**
+ *
+ * @param {number[]} result
+ * @param {number} origin_x
+ * @param {number} origin_y
+ * @param {number} origin_z
+ * @param {number} direction_x
+ * @param {number} direction_y
+ * @param {number} direction_z
+ * @param {number[]|ArrayLike<number>|Uint32Array} indices
+ * @param {number} triangle_index
+ * @param {number[]|Float32Array} positions
+ * @return {boolean}
+ */
+export function tri3_ray_intersection_indexed(
+    result,
+    origin_x, origin_y, origin_z,
+    direction_x, direction_y, direction_z,
+    indices, triangle_index, positions
+) {
+    const index_offset = triangle_index * 3;
+
+    const a = indices[index_offset];
+    const b = indices[index_offset + 1];
+    const c = indices[index_offset + 2];
+
+
+    const a_address = a * 3;
+    const b_address = b * 3;
+    const c_address = c * 3;
+
+
+    const ax = positions[a_address];
+    const ay = positions[a_address + 1];
+    const az = positions[a_address + 2];
+
+    const bx = positions[b_address];
+    const by = positions[b_address + 1];
+    const bz = positions[b_address + 2];
+
+    const cx = positions[c_address];
+    const cy = positions[c_address + 1];
+    const cz = positions[c_address + 2];
+
+    return tri3_ray_intersection_barycentric(
+        result,
+        origin_x, origin_y, origin_z,
+        direction_x, direction_y, direction_z,
+        ax, ay, az,
+        bx, by, bz,
+        cx, cy, cz
+    );
+}

package/src/core/geom/3d/triangle/tri3_ray_intersection_v3_objects.d.ts

@@ -0,0 +1,13 @@
+/**
+ * NOTE: adapted from http://www.geometrictools.com/GTEngine/Include/Mathematics/GteIntrRay3Triangle3.h
+ * @source https://en.wikipedia.org/wiki/M%C3%B6ller%E2%80%93Trumbore_intersection_algorithm (Möller and Trumbore, « Fast, Minimum Storage Ray-Triangle Intersection », Journal of Graphics Tools, vol. 2,‎ 1997, p. 21–28)
+ * @param {Vector3} result
+ * @param {Vector3} rayOrigin
+ * @param {Vector3} rayDirection
+ * @param {Vector3} a
+ * @param {Vector3} b
+ * @param {Vector3} c
+ * @returns {boolean}
+ */
+export function tri3_ray_intersection_v3_objects(result: Vector3, rayOrigin: Vector3, rayDirection: Vector3, a: Vector3, b: Vector3, c: Vector3): boolean;
+//# sourceMappingURL=tri3_ray_intersection_v3_objects.d.ts.map

package/src/core/geom/3d/triangle/tri3_ray_intersection_v3_objects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tri3_ray_intersection_v3_objects.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/tri3_ray_intersection_v3_objects.js"],"names":[],"mappings":"AAMA;;;;;;;;;;GAUG;AACH,kJAFa,OAAO,CAoBnB"}

package/src/core/geom/3d/triangle/tri3_ray_intersection_v3_objects.js

@@ -0,0 +1,37 @@
+import { SurfacePoint3 } from "../SurfacePoint3.js";
+import { tri3_ray_intersection } from "./tri3_ray_intersection.js";
+
+
+const sp3 = new SurfacePoint3();
+
+/**
+ * NOTE: adapted from http://www.geometrictools.com/GTEngine/Include/Mathematics/GteIntrRay3Triangle3.h
+ * @source https://en.wikipedia.org/wiki/M%C3%B6ller%E2%80%93Trumbore_intersection_algorithm (Möller and Trumbore, « Fast, Minimum Storage Ray-Triangle Intersection », Journal of Graphics Tools, vol. 2,‎ 1997, p. 21–28)
+ * @param {Vector3} result
+ * @param {Vector3} rayOrigin
+ * @param {Vector3} rayDirection
+ * @param {Vector3} a
+ * @param {Vector3} b
+ * @param {Vector3} c
+ * @returns {boolean}
+ */
+export function tri3_ray_intersection_v3_objects(
+    result,
+    rayOrigin, rayDirection,
+    a, b, c
+) {
+
+    const hit_found = tri3_ray_intersection(
+        sp3,
+        rayOrigin.x, rayOrigin.y, rayOrigin.z,
+        rayDirection.x, rayDirection.y, rayDirection.z,
+        a.x, a.y, a.z,
+        b.x, b.y, b.z,
+        c.x, c.y, c.z
+    );
+
+    result.copy(sp3.position);
+
+    return hit_found;
+}
+

package/src/core/geom/3d/triangle/triangle3_incenter.d.ts

@@ -1,19 +1,7 @@
 /**
- * Calculates the incenter of a triangle.
- *
- * @see https://en.wikipedia.org/wiki/Incenter
- * @param {number[]|Float32Array|Float64Array|ArrayLike<number>} output
- * @param {number} output_offset
- * @param {number} x0
- * @param {number} y0
- * @param {number} z0
- * @param {number} x1
- * @param {number} y1
- * @param {number} z1
- * @param {number} x2
- * @param {number} y2
- * @param {number} z2
- * @returns {boolean} true when the result was calculated, false for degenerate triangle
+ * @deprecated Renamed to {@link tri3_incenter}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
  */
-export function triangle3_incenter(output: number[] | Float32Array | Float64Array | ArrayLike<number>, output_offset: number, x0: number, y0: number, z0: number, x1: number, y1: number, z1: number, x2: number, y2: number, z2: number): boolean;
+export const triangle3_incenter: typeof tri3_incenter;
+import { tri3_incenter } from "./tri3_incenter.js";
 //# sourceMappingURL=triangle3_incenter.d.ts.map

package/src/core/geom/3d/triangle/triangle3_incenter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"triangle3_incenter.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/triangle3_incenter.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,2CAbW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,GAAC,UAAU,MAAM,CAAC,iBACpD,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,OAAO,CA4CnB"}
+{"version":3,"file":"triangle3_incenter.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/triangle3_incenter.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,sDAAgD;8BANlB,oBAAoB"}

package/src/core/geom/3d/triangle/triangle3_incenter.js

@@ -1,60 +1,7 @@
-/**
- * Calculates the incenter of a triangle.
- *
- * @see https://en.wikipedia.org/wiki/Incenter
- * @param {number[]|Float32Array|Float64Array|ArrayLike<number>} output
- * @param {number} output_offset
- * @param {number} x0
- * @param {number} y0
- * @param {number} z0
- * @param {number} x1
- * @param {number} y1
- * @param {number} z1
- * @param {number} x2
- * @param {number} y2
- * @param {number} z2
- * @returns {boolean} true when the result was calculated, false for degenerate triangle
- */
-export function triangle3_incenter(
-    output, output_offset,
-    x0, y0, z0,
-    x1, y1, z1,
-    x2, y2, z2
-) {
-    // Calculate edge lengths opposite to each vertex
-
-    // 'a' is length of edge v1-v2 (opposite v0)
-    const dxA = x2 - x1;
-    const dyA = y2 - y1;
-    const dzA = z2 - z1;
-
-    const a = Math.sqrt(dxA * dxA + dyA * dyA + dzA * dzA);
-
-    // 'b' is length of edge v2-v0 (opposite v1)
-    const dxB = x0 - x2;
-    const dyB = y0 - y2;
-    const dzB = z0 - z2;
-
-    const b = Math.sqrt(dxB * dxB + dyB * dyB + dzB * dzB);
-
-    // 'c' is length of edge v0-v1 (opposite v2)
-    const dxC = x1 - x0;
-    const dyC = y1 - y0;
-    const dzC = z1 - z0;
-
-    const c = Math.sqrt(dxC * dxC + dyC * dyC + dzC * dzC);
-
-    const perimeter = a + b + c;
-
-    if (perimeter <= 0) {
-        // 0 perimeter triangle
-        return false;
-    }
-
-    output[output_offset] = (a * x0 + b * x1 + c * x2) / perimeter;
-    output[output_offset + 1] = (a * y0 + b * y1 + c * y2) / perimeter;
-    output[output_offset + 2] = (a * z0 + b * z1 + c * z2) / perimeter;
-
-    return true;
-
-}
+import { tri3_incenter } from "./tri3_incenter.js";
+
+/**
+ * @deprecated Renamed to {@link tri3_incenter}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
+ */
+export const triangle3_incenter = tri3_incenter;

package/src/core/geom/3d/triangle/triangle_compute_plane_side.d.ts

@@ -1,24 +1,7 @@
 /**
- * Produces a numeric result to indicate which side of the plane the triangle is on
- * between +3 and -3:
- *      +3 means that all vertices ave above the plane
- *      -3 means all vertices are below the plane
- *      values in between indicate that the plane cuts through the triangle
- *
- * @param {number} plane_normal_x
- * @param {number} plane_normal_y
- * @param {number} plane_normal_z
- * @param {number} plane_constant
- * @param {number} ax
- * @param {number} ay
- * @param {number} az
- * @param {number} bx
- * @param {number} by
- * @param {number} bz
- * @param {number} cx
- * @param {number} cy
- * @param {number} cz
- * @returns {number}
+ * @deprecated Renamed to {@link tri3_compute_plane_side}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
  */
-export function triangle_compute_plane_side(plane_normal_x: number, plane_normal_y: number, plane_normal_z: number, plane_constant: number, ax: number, ay: number, az: number, bx: number, by: number, bz: number, cx: number, cy: number, cz: number): number;
+export const triangle_compute_plane_side: typeof tri3_compute_plane_side;
+import { tri3_compute_plane_side } from "./tri3_compute_plane_side.js";
 //# sourceMappingURL=triangle_compute_plane_side.d.ts.map

package/src/core/geom/3d/triangle/triangle_compute_plane_side.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"triangle_compute_plane_side.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/triangle_compute_plane_side.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,4DAfW,MAAM,kBACN,MAAM,kBACN,MAAM,kBACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAgBlB"}
+{"version":3,"file":"triangle_compute_plane_side.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/triangle_compute_plane_side.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,yEAAmE;wCAN3B,8BAA8B"}