@woosh/meep-engine 2.163.10 → 2.164.0

package/src/core/geom/vec3/v3_interior_angle.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Compute interior angle between three points
+ * Computed angle is around point B
+ * @param {{x:number, y:number, z:number}} a
+ * @param {{x:number, y:number, z:number}} b
+ * @param {{x:number, y:number, z:number}} c
+ * @returns {number} angle in radians
+ */
+export function v3_interior_angle(a: {
+    x: number;
+    y: number;
+    z: number;
+}, b: {
+    x: number;
+    y: number;
+    z: number;
+}, c: {
+    x: number;
+    y: number;
+    z: number;
+}): number;
+//# sourceMappingURL=v3_interior_angle.d.ts.map

package/src/core/geom/vec3/v3_interior_angle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"v3_interior_angle.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_interior_angle.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,qCALW;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAA;CAAC,KAC9B;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAA;CAAC,KAC9B;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAA;CAAC,GAC5B,MAAM,CAiBlB"}

package/src/core/geom/vec3/v3_interior_angle.js

@@ -0,0 +1,26 @@
+import { v3_angle } from "./v3_angle.js";
+
+/**
+ * Compute interior angle between three points
+ * Computed angle is around point B
+ * @param {{x:number, y:number, z:number}} a
+ * @param {{x:number, y:number, z:number}} b
+ * @param {{x:number, y:number, z:number}} c
+ * @returns {number} angle in radians
+ */
+export function v3_interior_angle(a, b, c) {
+    //compute AB delta
+    const d_ab_x = a.x - b.x;
+    const d_ab_y = a.y - b.y;
+    const d_ab_z = a.z - b.z;
+
+    //compute CB delta
+    const d_cb_x = c.x - b.x;
+    const d_cb_y = c.y - b.y;
+    const d_cb_z = c.z - b.z;
+
+    return v3_angle(
+        d_ab_x, d_ab_y, d_ab_z,
+        d_cb_x, d_cb_y, d_cb_z,
+    )
+}

package/src/core/geom/vec3/v3_matrix3_rotate.d.ts

@@ -5,12 +5,12 @@
  * Correctly handles non-uniform scaling.
  * Output is normalized.
  *
- * @param {number[]|Float32Array} output
+ * @param {number[]|Float32Array|Float64Array} output
  * @param {number} output_offset
  * @param {number} x
  * @param {number} y
  * @param {number} z
- * @param {number[]|Float32Array} mat3
+ * @param {number[]|Float32Array|Float64Array} mat3
  */
-export function v3_matrix3_rotate(output: number[] | Float32Array, output_offset: number, x: number, y: number, z: number, mat3: number[] | Float32Array): void;
+export function v3_matrix3_rotate(output: number[] | Float32Array | Float64Array, output_offset: number, x: number, y: number, z: number, mat3: number[] | Float32Array | Float64Array): void;
 //# sourceMappingURL=v3_matrix3_rotate.d.ts.map

package/src/core/geom/vec3/v3_matrix3_rotate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"v3_matrix3_rotate.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_matrix3_rotate.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,0CAPW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QACN,MAAM,EAAE,GAAC,YAAY,QAkC/B"}
+{"version":3,"file":"v3_matrix3_rotate.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_matrix3_rotate.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,0CAPW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,QAkC5C"}

package/src/core/geom/vec3/v3_matrix3_rotate.js

@@ -7,12 +7,12 @@ import { v3_length } from "./v3_length.js";
  * Correctly handles non-uniform scaling.
  * Output is normalized.
  *
- * @param {number[]|Float32Array} output
+ * @param {number[]|Float32Array|Float64Array} output
  * @param {number} output_offset
  * @param {number} x
  * @param {number} y
  * @param {number} z
- * @param {number[]|Float32Array} mat3
+ * @param {number[]|Float32Array|Float64Array} mat3
  */
 export function v3_matrix3_rotate(
     output, output_offset,

package/src/core/geom/vec3/v3_matrix4_rotate.d.ts

@@ -1,16 +1,7 @@
 /**
- *
- * Perform rotation on a direction vector using a 4x4 affine transform matrix.
- * Input is expected to be normalized.
- * Correctly handles non-uniform scaling.
- * Output is normalized.
- *
- * @param {number[]|Float32Array} output
- * @param {number} output_offset
- * @param {number} x
- * @param {number} y
- * @param {number} z
- * @param {number[]|Float32Array} m4
+ * @deprecated Renamed to {@link v3_matrix4_rotate_unit}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
  */
-export function v3_matrix4_rotate(output: number[] | Float32Array, output_offset: number, x: number, y: number, z: number, m4: number[] | Float32Array): void;
+export const v3_matrix4_rotate: typeof v3_matrix4_rotate_unit;
+import { v3_matrix4_rotate_unit } from "./v3_matrix4_rotate_unit.js";
 //# sourceMappingURL=v3_matrix4_rotate.d.ts.map

package/src/core/geom/vec3/v3_matrix4_rotate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"v3_matrix4_rotate.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_matrix4_rotate.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,0CAPW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,MACN,MAAM,EAAE,GAAC,YAAY,QAkC/B"}
+{"version":3,"file":"v3_matrix4_rotate.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_matrix4_rotate.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,8DAAwD;uCANjB,6BAA6B"}

package/src/core/geom/vec3/v3_matrix4_rotate.js

@@ -1,51 +1,7 @@
-import { v3_length } from "./v3_length.js";
-
-/**
- *
- * Perform rotation on a direction vector using a 4x4 affine transform matrix.
- * Input is expected to be normalized.
- * Correctly handles non-uniform scaling.
- * Output is normalized.
- *
- * @param {number[]|Float32Array} output
- * @param {number} output_offset
- * @param {number} x
- * @param {number} y
- * @param {number} z
- * @param {number[]|Float32Array} m4
- */
-export function v3_matrix4_rotate(
-    output, output_offset,
-    x, y, z,
-    m4
-) {
-
-    const _x = m4[0] * x + m4[4] * y + m4[8] * z;
-    const _y = m4[1] * x + m4[5] * y + m4[9] * z;
-    const _z = m4[2] * x + m4[6] * y + m4[10] * z;
-
-    // perform normalization
-    const length = v3_length(_x, _y, _z);
-
-    if (length > 1e-7) {
-
-        // re-normalize
-        const norm = 1 / length;
-
-        output[output_offset] = _x * norm;
-        output[output_offset + 1] = _y * norm;
-        output[output_offset + 2] = _z * norm;
-
-    } else {
-
-        // The transform is invalid.
-        // Provide arbitrary vector.
-
-        output[output_offset] = 0;
-        output[output_offset + 1] = 0;
-        output[output_offset + 2] = 0;
-
-    }
-}
-
-
+import { v3_matrix4_rotate_unit } from "./v3_matrix4_rotate_unit.js";
+
+/**
+ * @deprecated Renamed to {@link v3_matrix4_rotate_unit}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
+ */
+export const v3_matrix4_rotate = v3_matrix4_rotate_unit;

package/src/core/geom/vec3/v3_matrix4_rotate_array.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Perform rotation on a direction vector using 3x3 portion of a 4x4 matrix
+ * NOTE: produces a normalized vector
+ * @param {number[]|Float32Array} output
+ * @param {number} output_offset
+ * @param {number[]|Float32Array} input
+ * @param {number} input_offset
+ * @param {number[]|Float32Array} m4
+ */
+export function v3_matrix4_rotate_array(output: number[] | Float32Array, output_offset: number, input: number[] | Float32Array, input_offset: number, m4: number[] | Float32Array): void;
+//# sourceMappingURL=v3_matrix4_rotate_array.d.ts.map

package/src/core/geom/vec3/v3_matrix4_rotate_array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"v3_matrix4_rotate_array.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_matrix4_rotate_array.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,gDANW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,SACN,MAAM,EAAE,GAAC,YAAY,gBACrB,MAAM,MACN,MAAM,EAAE,GAAC,YAAY,QAY/B"}

package/src/core/geom/vec3/v3_matrix4_rotate_array.js

@@ -0,0 +1,22 @@
+import { v3_matrix4_rotate_unit } from "./v3_matrix4_rotate_unit.js";
+
+/**
+ * Perform rotation on a direction vector using 3x3 portion of a 4x4 matrix
+ * NOTE: produces a normalized vector
+ * @param {number[]|Float32Array} output
+ * @param {number} output_offset
+ * @param {number[]|Float32Array} input
+ * @param {number} input_offset
+ * @param {number[]|Float32Array} m4
+ */
+export function v3_matrix4_rotate_array(
+    output, output_offset,
+    input, input_offset,
+    m4
+) {
+    const x = input[input_offset];
+    const y = input[input_offset + 1];
+    const z = input[input_offset + 2];
+
+    v3_matrix4_rotate_unit(output,output_offset,x,y,z,m4);
+}

package/src/core/geom/vec3/v3_matrix4_rotate_unit.d.ts

@@ -0,0 +1,16 @@
+/**
+ *
+ * Perform rotation on a direction vector using a 4x4 affine transform matrix.
+ * Input is expected to be normalized.
+ * Correctly handles non-uniform scaling.
+ * Output is normalized.
+ *
+ * @param {number[]|Float32Array} output
+ * @param {number} output_offset
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @param {number[]|Float32Array} m4
+ */
+export function v3_matrix4_rotate_unit(output: number[] | Float32Array, output_offset: number, x: number, y: number, z: number, m4: number[] | Float32Array): void;
+//# sourceMappingURL=v3_matrix4_rotate_unit.d.ts.map

package/src/core/geom/vec3/v3_matrix4_rotate_unit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"v3_matrix4_rotate_unit.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_matrix4_rotate_unit.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,+CAPW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,MACN,MAAM,EAAE,GAAC,YAAY,QAkC/B"}

package/src/core/geom/vec3/v3_matrix4_rotate_unit.js

@@ -0,0 +1,51 @@
+import { v3_length } from "./v3_length.js";
+
+/**
+ *
+ * Perform rotation on a direction vector using a 4x4 affine transform matrix.
+ * Input is expected to be normalized.
+ * Correctly handles non-uniform scaling.
+ * Output is normalized.
+ *
+ * @param {number[]|Float32Array} output
+ * @param {number} output_offset
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @param {number[]|Float32Array} m4
+ */
+export function v3_matrix4_rotate_unit(
+    output, output_offset,
+    x, y, z,
+    m4
+) {
+
+    const _x = m4[0] * x + m4[4] * y + m4[8] * z;
+    const _y = m4[1] * x + m4[5] * y + m4[9] * z;
+    const _z = m4[2] * x + m4[6] * y + m4[10] * z;
+
+    // perform normalization
+    const length = v3_length(_x, _y, _z);
+
+    if (length > 1e-7) {
+
+        // re-normalize
+        const norm = 1 / length;
+
+        output[output_offset] = _x * norm;
+        output[output_offset + 1] = _y * norm;
+        output[output_offset + 2] = _z * norm;
+
+    } else {
+
+        // The transform is invalid.
+        // Provide arbitrary vector.
+
+        output[output_offset] = 0;
+        output[output_offset + 1] = 0;
+        output[output_offset + 2] = 0;
+
+    }
+}
+
+

package/src/core/geom/vec3/v3_multiply_scalar.d.ts

@@ -1,11 +1,7 @@
 /**
- *
- * @param {number[]|Float64Array|Float32Array} result
- * @param {number} result_offset
- * @param {number} x
- * @param {number} y
- * @param {number} z
- * @param {number} scalar
+ * @deprecated Renamed to {@link v3_scale}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
  */
-export function v3_multiply_scalar(result: number[] | Float64Array | Float32Array, result_offset: number, x: number, y: number, z: number, scalar: number): void;
+export const v3_multiply_scalar: typeof v3_scale;
+import { v3_scale } from "./v3_scale.js";
 //# sourceMappingURL=v3_multiply_scalar.d.ts.map

package/src/core/geom/vec3/v3_multiply_scalar.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"v3_multiply_scalar.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_multiply_scalar.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,2CAPW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,UACN,MAAM,QAWhB"}
+{"version":3,"file":"v3_multiply_scalar.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_multiply_scalar.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,iDAA2C;yBANlB,eAAe"}

package/src/core/geom/vec3/v3_multiply_scalar.js

@@ -1,19 +1,7 @@
-/**
- *
- * @param {number[]|Float64Array|Float32Array} result
- * @param {number} result_offset
- * @param {number} x
- * @param {number} y
- * @param {number} z
- * @param {number} scalar
- */
-export function v3_multiply_scalar(
-    result, result_offset,
-    x, y, z, scalar
-) {
-
-    result[result_offset] = x * scalar;
-    result[result_offset + 1] = y * scalar;
-    result[result_offset + 2] = z * scalar;
-
-}
+import { v3_scale } from "./v3_scale.js";
+
+/**
+ * @deprecated Renamed to {@link v3_scale}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
+ */
+export const v3_multiply_scalar = v3_scale;

package/src/core/geom/vec3/v3_normalize_array.d.ts

@@ -0,0 +1,9 @@
+/**
+ *
+ * @param {number[]|Float32Array} output
+ * @param {number} output_offset
+ * @param {number[]|Float32Array} input
+ * @param {number} input_offset
+ */
+export function v3_normalize_array(output: number[] | Float32Array, output_offset: number, input: number[] | Float32Array, input_offset: number): void;
+//# sourceMappingURL=v3_normalize_array.d.ts.map

package/src/core/geom/vec3/v3_normalize_array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"v3_normalize_array.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_normalize_array.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,2CALW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,SACN,MAAM,EAAE,GAAC,YAAY,gBACrB,MAAM,QAwBhB"}

package/src/core/geom/vec3/v3_normalize_array.js

@@ -0,0 +1,32 @@
+import { v3_length_sqr } from "./v3_length_sqr.js";
+
+/**
+ *
+ * @param {number[]|Float32Array} output
+ * @param {number} output_offset
+ * @param {number[]|Float32Array} input
+ * @param {number} input_offset
+ */
+export function v3_normalize_array(
+    output, output_offset,
+    input, input_offset,
+) {
+
+
+    // extract vector components
+    const x = input[input_offset];
+    const y = input[input_offset + 1];
+    const z = input[input_offset + 2];
+
+    // compute vector inverse magnitude
+    const length_sqr = v3_length_sqr(x, y, z);
+
+    // avoid division by 0
+    const n = length_sqr !== 0 ? 1.0 / Math.sqrt(length_sqr) : 1;
+
+    // write back
+    output[output_offset] = x * n;
+    output[output_offset + 1] = y * n;
+    output[output_offset + 2] = z * n;
+
+}

package/src/core/geom/vec3/v3_orthonormal_matrix_from_normal.d.ts

@@ -1,5 +1,8 @@
 /**
- * Build orthonormal matrix from direction vector
+ * Build orthonormal matrix from direction vector.
+ * PRECONDITION: the direction (dir_x, dir_y, dir_z) MUST be a unit vector. A non-unit input
+ * yields a non-orthonormal (broken) basis - the third basis vector is the input as-is and the
+ * second is scaled by its length.
  * @param {number[]|Float32Array|Float64Array} out
  * @param {number} out_offset
  * @param {number} dir_x

package/src/core/geom/vec3/v3_orthonormal_matrix_from_normal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"v3_orthonormal_matrix_from_normal.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_orthonormal_matrix_from_normal.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,uDANW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,QAsChB"}
+{"version":3,"file":"v3_orthonormal_matrix_from_normal.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_orthonormal_matrix_from_normal.js"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,uDANW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,QAsChB"}

package/src/core/geom/vec3/v3_orthonormal_matrix_from_normal.js

@@ -1,7 +1,10 @@
 import { v3_length } from "./v3_length.js";
 
 /**
- * Build orthonormal matrix from direction vector
+ * Build orthonormal matrix from direction vector.
+ * PRECONDITION: the direction (dir_x, dir_y, dir_z) MUST be a unit vector. A non-unit input
+ * yields a non-orthonormal (broken) basis - the third basis vector is the input as-is and the
+ * second is scaled by its length.
  * @param {number[]|Float32Array|Float64Array} out
  * @param {number} out_offset
  * @param {number} dir_x

package/src/core/geom/vec3/v3_quat3_apply.d.ts

@@ -1,29 +1,7 @@
 /**
- * Rotate a 3-D vector by a unit quaternion: `result = q · v · q*`.
- *
- * The closed-form expansion below is the standard "two Hamilton
- * products with a pure-quaternion v" derivation. We compute the
- * intermediate `t = q · v` (treating v as a quaternion with `w = 0`),
- * then `result = t · q*` (where `q* = (-qx, -qy, -qz, qw)`). Inline
- * the sign of the conjugate so the final multiplies avoid temporary
- * negations.
- *
- * Sign convention: `(qx, qy, qz, qw)` — `w` last, matching the
- * project's existing {@link Quaternion} class and the rest of the
- * `core/geom/3d/quaternion/` family.
- *
- * Companion to {@link v3_quat3_apply_inverse} (rotates by the
- * conjugate, i.e. inverse rotation).
- *
- * @param {number[]|Float32Array|Float64Array} out
- * @param {number} out_offset offset into `out`; receives 3 floats
- * @param {number} vx
- * @param {number} vy
- * @param {number} vz
- * @param {number} qx unit quaternion x
- * @param {number} qy
- * @param {number} qz
- * @param {number} qw unit quaternion w (last)
+ * @deprecated Renamed to {@link v3_quaternion_apply}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
  */
-export function v3_quat3_apply(out: number[] | Float32Array | Float64Array, out_offset: number, vx: number, vy: number, vz: number, qx: number, qy: number, qz: number, qw: number): void;
+export const v3_quat3_apply: typeof v3_quaternion_apply;
+import { v3_quaternion_apply } from "./v3_quaternion_apply.js";
 //# sourceMappingURL=v3_quat3_apply.d.ts.map

package/src/core/geom/vec3/v3_quat3_apply.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"v3_quat3_apply.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_quat3_apply.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,oCAVW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAahB"}
+{"version":3,"file":"v3_quat3_apply.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_quat3_apply.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,wDAAkD;oCANd,0BAA0B"}

package/src/core/geom/vec3/v3_quat3_apply.js

@@ -1,39 +1,7 @@
+import { v3_quaternion_apply } from "./v3_quaternion_apply.js";
+
 /**
- * Rotate a 3-D vector by a unit quaternion: `result = q · v · q*`.
- *
- * The closed-form expansion below is the standard "two Hamilton
- * products with a pure-quaternion v" derivation. We compute the
- * intermediate `t = q · v` (treating v as a quaternion with `w = 0`),
- * then `result = t · q*` (where `q* = (-qx, -qy, -qz, qw)`). Inline
- * the sign of the conjugate so the final multiplies avoid temporary
- * negations.
- *
- * Sign convention: `(qx, qy, qz, qw)` — `w` last, matching the
- * project's existing {@link Quaternion} class and the rest of the
- * `core/geom/3d/quaternion/` family.
- *
- * Companion to {@link v3_quat3_apply_inverse} (rotates by the
- * conjugate, i.e. inverse rotation).
- *
- * @param {number[]|Float32Array|Float64Array} out
- * @param {number} out_offset offset into `out`; receives 3 floats
- * @param {number} vx
- * @param {number} vy
- * @param {number} vz
- * @param {number} qx unit quaternion x
- * @param {number} qy
- * @param {number} qz
- * @param {number} qw unit quaternion w (last)
+ * @deprecated Renamed to {@link v3_quaternion_apply}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
  */
-export function v3_quat3_apply(out, out_offset, vx, vy, vz, qx, qy, qz, qw) {
-    // t = q · v   (Hamilton product, v as pure quaternion w=0)
-    const tx =  qw * vx + qy * vz - qz * vy;
-    const ty =  qw * vy + qz * vx - qx * vz;
-    const tz =  qw * vz + qx * vy - qy * vx;
-    const tw = -qx * vx - qy * vy - qz * vz;
-
-    // result = t · q*   (q* = -qx, -qy, -qz, qw)
-    out[out_offset]     = tx * qw - tw * qx - ty * qz + tz * qy;
-    out[out_offset + 1] = ty * qw - tw * qy - tz * qx + tx * qz;
-    out[out_offset + 2] = tz * qw - tw * qz - tx * qy + ty * qx;
-}
+export const v3_quat3_apply = v3_quaternion_apply;

package/src/core/geom/vec3/v3_quat3_apply_inverse.d.ts

@@ -1,30 +1,7 @@
 /**
- * Inverse-rotate a 3-D vector by a unit quaternion: `result = q* · v · q`,
- * where `q* = (-qx, -qy, -qz, qw)` is the conjugate.
- *
- * Geometrically: if {@link v3_quat3_apply} rotates a body-local vector
- * into world space (`v_world = q · v_local · q*`), this is the inverse —
- * it takes a world-space vector and writes it in body-local coordinates.
- * For unit quaternions the conjugate IS the inverse, so the two
- * functions are exact inverses of each other.
- *
- * Implementation: the conjugate's `xyz` are negated relative to `q`.
- * Expanding `c · v · c*` with `(cx, cy, cz, cw) = (-qx, -qy, -qz, qw)`
- * and simplifying produces the closed form below — different sign
- * pattern than {@link v3_quat3_apply}, NOT just a call with negated
- * components (the optimisation matters for hot-path callers such as
- * `PosedShape3D.support` and the per-triangle concave dispatch in
- * `narrowphase_step`).
- *
- * @param {number[]|Float32Array|Float64Array} out
- * @param {number} out_offset offset into `out`; receives 3 floats
- * @param {number} vx
- * @param {number} vy
- * @param {number} vz
- * @param {number} qx unit quaternion x
- * @param {number} qy
- * @param {number} qz
- * @param {number} qw unit quaternion w (last)
+ * @deprecated Renamed to {@link v3_quaternion_apply_inverse}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
  */
-export function v3_quat3_apply_inverse(out: number[] | Float32Array | Float64Array, out_offset: number, vx: number, vy: number, vz: number, qx: number, qy: number, qz: number, qw: number): void;
+export const v3_quat3_apply_inverse: typeof v3_quaternion_apply_inverse;
+import { v3_quaternion_apply_inverse } from "./v3_quaternion_apply_inverse.js";
 //# sourceMappingURL=v3_quat3_apply_inverse.d.ts.map

package/src/core/geom/vec3/v3_quat3_apply_inverse.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"v3_quat3_apply_inverse.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_quat3_apply_inverse.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,4CAVW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAchB"}
+{"version":3,"file":"v3_quat3_apply_inverse.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_quat3_apply_inverse.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,wEAAkE;4CANtB,kCAAkC"}

package/src/core/geom/vec3/v3_quat3_apply_inverse.js

@@ -1,41 +1,7 @@
+import { v3_quaternion_apply_inverse } from "./v3_quaternion_apply_inverse.js";
+
 /**
- * Inverse-rotate a 3-D vector by a unit quaternion: `result = q* · v · q`,
- * where `q* = (-qx, -qy, -qz, qw)` is the conjugate.
- *
- * Geometrically: if {@link v3_quat3_apply} rotates a body-local vector
- * into world space (`v_world = q · v_local · q*`), this is the inverse —
- * it takes a world-space vector and writes it in body-local coordinates.
- * For unit quaternions the conjugate IS the inverse, so the two
- * functions are exact inverses of each other.
- *
- * Implementation: the conjugate's `xyz` are negated relative to `q`.
- * Expanding `c · v · c*` with `(cx, cy, cz, cw) = (-qx, -qy, -qz, qw)`
- * and simplifying produces the closed form below — different sign
- * pattern than {@link v3_quat3_apply}, NOT just a call with negated
- * components (the optimisation matters for hot-path callers such as
- * `PosedShape3D.support` and the per-triangle concave dispatch in
- * `narrowphase_step`).
- *
- * @param {number[]|Float32Array|Float64Array} out
- * @param {number} out_offset offset into `out`; receives 3 floats
- * @param {number} vx
- * @param {number} vy
- * @param {number} vz
- * @param {number} qx unit quaternion x
- * @param {number} qy
- * @param {number} qz
- * @param {number} qw unit quaternion w (last)
+ * @deprecated Renamed to {@link v3_quaternion_apply_inverse}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
  */
-export function v3_quat3_apply_inverse(out, out_offset, vx, vy, vz, qx, qy, qz, qw) {
-    // t = q* · v   (conjugate · v, v as pure quaternion w=0)
-    // Conjugate xyz negated; expanded:
-    const tx = qw * vx - qy * vz + qz * vy;
-    const ty = qw * vy - qz * vx + qx * vz;
-    const tz = qw * vz - qx * vy + qy * vx;
-    const tw = qx * vx + qy * vy + qz * vz; // note: +, conjugate-w stays qw
-
-    // result = t · q   (q is the conjugate-of-conjugate)
-    out[out_offset]     = tx * qw + tw * qx + ty * qz - tz * qy;
-    out[out_offset + 1] = ty * qw + tw * qy + tz * qx - tx * qz;
-    out[out_offset + 2] = tz * qw + tw * qz + tx * qy - ty * qx;
-}
+export const v3_quat3_apply_inverse = v3_quaternion_apply_inverse;

package/src/core/geom/vec3/v3_quaternion_apply.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Rotate a 3-D vector by a unit quaternion: `result = q · v · q*`.
+ *
+ * The closed-form expansion below is the standard "two Hamilton
+ * products with a pure-quaternion v" derivation. We compute the
+ * intermediate `t = q · v` (treating v as a quaternion with `w = 0`),
+ * then `result = t · q*` (where `q* = (-qx, -qy, -qz, qw)`). Inline
+ * the sign of the conjugate so the final multiplies avoid temporary
+ * negations.
+ *
+ * Sign convention: `(qx, qy, qz, qw)` — `w` last, matching the
+ * project's existing {@link Quaternion} class and the rest of the
+ * `core/geom/3d/quaternion/` family.
+ *
+ * Companion to {@link v3_quat3_apply_inverse} (rotates by the
+ * conjugate, i.e. inverse rotation).
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset offset into `out`; receives 3 floats
+ * @param {number} vx
+ * @param {number} vy
+ * @param {number} vz
+ * @param {number} qx unit quaternion x
+ * @param {number} qy
+ * @param {number} qz
+ * @param {number} qw unit quaternion w (last)
+ */
+export function v3_quaternion_apply(out: number[] | Float32Array | Float64Array, out_offset: number, vx: number, vy: number, vz: number, qx: number, qy: number, qz: number, qw: number): void;
+//# sourceMappingURL=v3_quaternion_apply.d.ts.map

package/src/core/geom/vec3/v3_quaternion_apply.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"v3_quaternion_apply.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_quaternion_apply.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,yCAVW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAahB"}