@woosh/meep-engine 2.163.10 → 2.164.0

package/src/core/geom/3d/mat4/eulerAnglesFromMatrix.d.ts

@@ -1,33 +1,7 @@
 /**
- *
- * returns the Euler-angles of the rotation matrix \c *this using the convention defined by the triplet (`a0`,`a1`,`a2`)
- *
- * Each of the three parameters `a0`, `a1`, `a2` represents the respective rotation axis as an integer in {0,1,2}.
- * For instance, in:
- * ```
- * Vector3f ea = mat.eulerAngles(2, 0, 2);
- * ```
- * "2" represents the z axis and "0" the x axis, etc. The returned angles are such that
- * we have the following equality:
- * ```
- * mat == AngleAxisf(ea[0], Vector3f::UnitZ())
- *      * AngleAxisf(ea[1], Vector3f::UnitX())
- *      * AngleAxisf(ea[2], Vector3f::UnitZ());
- * ```
- * This corresponds to the right-multiply conventions (with right hand side frames).
- *
- * The returned angles are in the ranges [0:pi]x[-pi:pi]x[-pi:pi].
-
- * NOTE: ported from Eigen C++ library
- *
- * @see https://gitlab.com/libeigen/eigen/-/blob/master/Eigen/src/Geometry/EulerAngles.h
- * @see https://stackoverflow.com/questions/11514063/extract-yaw-pitch-and-roll-from-a-rotationmatrix
- *
- * @param {number[]} output
- * @param {number[]|Float32Array|mat4} m4 source matrix to extract rotation from
- * @param {number} a0 axis index (0 = X, 1 = Y, 2 = Z)
- * @param {number} a1 axis index
- * @param {number} a2 axis index
+ * @deprecated Renamed to {@link m4_euler_angles}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
  */
-export function eulerAnglesFromMatrix(output: number[], m4: number[] | Float32Array | mat4, a0: number, a1: number, a2: number): void;
+export const eulerAnglesFromMatrix: typeof m4_euler_angles;
+import { m4_euler_angles } from "./m4_euler_angles.js";
 //# sourceMappingURL=eulerAnglesFromMatrix.d.ts.map

package/src/core/geom/3d/mat4/eulerAnglesFromMatrix.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"eulerAnglesFromMatrix.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/mat4/eulerAnglesFromMatrix.js"],"names":[],"mappings":"AAmBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,8CANW,MAAM,EAAE,MACR,MAAM,EAAE,GAAC,YAAY,OAAK,MAC1B,MAAM,MACN,MAAM,MACN,MAAM,QA2EhB"}
+{"version":3,"file":"eulerAnglesFromMatrix.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/mat4/eulerAnglesFromMatrix.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,2DAAqD;gCANrB,sBAAsB"}

package/src/core/geom/3d/mat4/eulerAnglesFromMatrix.js

@@ -1,124 +1,7 @@
-import { v2_length } from "../../vec2/v2_length.js";
-
-
-/**
- *
- * @param {number[]} mat4
- * @param {number} row_index
- * @param {number} column_index
- * @return {number}
- * @ignore
- */
-function coeff(mat4, row_index, column_index) {
-    return mat4[row_index + column_index * 4];
-}
-
-const sin = Math.sin;
-const cos = Math.cos;
-const atan2 = Math.atan2;
-
-/**
- *
- * returns the Euler-angles of the rotation matrix \c *this using the convention defined by the triplet (`a0`,`a1`,`a2`)
- *
- * Each of the three parameters `a0`, `a1`, `a2` represents the respective rotation axis as an integer in {0,1,2}.
- * For instance, in:
- * ```
- * Vector3f ea = mat.eulerAngles(2, 0, 2);
- * ```
- * "2" represents the z axis and "0" the x axis, etc. The returned angles are such that
- * we have the following equality:
- * ```
- * mat == AngleAxisf(ea[0], Vector3f::UnitZ())
- *      * AngleAxisf(ea[1], Vector3f::UnitX())
- *      * AngleAxisf(ea[2], Vector3f::UnitZ());
- * ```
- * This corresponds to the right-multiply conventions (with right hand side frames).
- *
- * The returned angles are in the ranges [0:pi]x[-pi:pi]x[-pi:pi].
-
- * NOTE: ported from Eigen C++ library
- *
- * @see https://gitlab.com/libeigen/eigen/-/blob/master/Eigen/src/Geometry/EulerAngles.h
- * @see https://stackoverflow.com/questions/11514063/extract-yaw-pitch-and-roll-from-a-rotationmatrix
- *
- * @param {number[]} output
- * @param {number[]|Float32Array|mat4} m4 source matrix to extract rotation from
- * @param {number} a0 axis index (0 = X, 1 = Y, 2 = Z)
- * @param {number} a1 axis index
- * @param {number} a2 axis index
- */
-export function eulerAnglesFromMatrix(
-    output, m4,
-    a0, a1, a2
-) {
-
-    const odd = ((a0 + 1) % 3 === a1) ? 0 : 1;
-
-    const i = a0;
-    const j = (a0 + 1 + odd) % 3;
-    const k = (a0 + 2 - odd) % 3;
-
-    if (a0 === a2) {
-        output[0] = atan2(coeff(m4, j, i), coeff(m4, k, i));
-
-        if ((odd && output[0] < 0) || ((!odd) && output[0] > 0)) {
-            if (output[0] > 0) {
-                output[0] -= Math.PI;
-            } else {
-                output[0] += Math.PI;
-            }
-            const s2 = v2_length(coeff(m4, j, i), coeff(m4, k, i));
-            output[1] = -atan2(s2, coeff(m4, i, i));
-        } else {
-            const s2 = v2_length(coeff(m4, j, i), coeff(m4, k, i));
-            output[1] = atan2(s2, coeff(m4, i, i));
-        }
-
-        // With a=(0,1,0), we have i=0; j=1; k=2, and after computing the first two angles,
-        // we can compute their respective rotation, and apply its inverse to M. Since the result must
-        // be a rotation around x, we have:
-        //
-        //  c2  s1.s2 c1.s2                   1  0   0
-        //  0   c1    -s1       *    M    =   0  c3  s3
-        //  -s2 s1.c2 c1.c2                   0 -s3  c3
-        //
-        //  Thus:  m11.c1 - m21.s1 = c3  &   m12.c1 - m22.s1 = s3
-
-        const s1 = sin(output[0]);
-        const c1 = cos(output[0]);
-
-        output[2] = atan2(c1 * coeff(m4, j, k) - s1 * coeff(m4, k, k), c1 * coeff(m4, j, j) - s1 * coeff(m4, k, j));
-
-    } else {
-
-        output[0] = atan2(coeff(m4, j, k), coeff(m4, k, k));
-
-        const c2 = v2_length(coeff(m4, i, i), coeff(m4, i, j));
-
-        if ((odd && output[0] < 0) || ((!odd) && output[0] > 0)) {
-            if (output[0] > 0) {
-                output[0] -= Math.PI;
-            } else {
-                output[0] += Math.PI;
-            }
-            output[1] = atan2(-coeff(m4, i, k), -c2);
-        } else {
-            output[1] = atan2(-coeff(m4, i, k), c2);
-        }
-
-        const s1 = sin(output[0]);
-        const c1 = cos(output[0]);
-
-        output[2] = atan2(s1 * coeff(m4, k, i) - c1 * coeff(m4, j, i), c1 * coeff(m4, j, j) - s1 * coeff(m4, k, j));
-
-    }
-
-    if (odd === 0) {
-        // invert result
-        output[0] = -output[0];
-        output[1] = -output[1];
-        output[2] = -output[2];
-    }
-
-}
+import { m4_euler_angles } from "./m4_euler_angles.js";
+
+/**
+ * @deprecated Renamed to {@link m4_euler_angles}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
+ */
+export const eulerAnglesFromMatrix = m4_euler_angles;

package/src/core/geom/3d/mat4/m4_allocate.d.ts

@@ -0,0 +1,6 @@
+/**
+ * custom Float32Array allocator
+ * @returns {Float32Array}
+ */
+export function m4_allocate(): Float32Array;
+//# sourceMappingURL=m4_allocate.d.ts.map

package/src/core/geom/3d/mat4/m4_allocate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"m4_allocate.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/mat4/m4_allocate.js"],"names":[],"mappings":"AAAA;;;GAGG;AACH,+BAFa,YAAY,CAaxB"}

package/src/core/geom/3d/mat4/m4_allocate.js

@@ -0,0 +1,16 @@
+/**
+ * custom Float32Array allocator
+ * @returns {Float32Array}
+ */
+export function m4_allocate() {
+
+    const result = new Float32Array(16);
+
+    // initialize to identity matrix by setting diagonal values
+    result[0] = 1;
+    result[5] = 1;
+    result[10] = 1;
+    result[15] = 1;
+
+    return result;
+}

package/src/core/geom/3d/mat4/m4_compose.d.ts

@@ -0,0 +1,22 @@
+/**
+ *
+ * @param {number[]|Float32Array|mat4} result
+ * @param { { x:number, y:number, z:number } } position
+ * @param { { x:number, y:number, z:number, w:number } } rotation
+ * @param { { x:number, y:number, z:number } } scale
+ */
+export function m4_compose(result: number[] | Float32Array | mat4, position: {
+    x: number;
+    y: number;
+    z: number;
+}, rotation: {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+}, scale: {
+    x: number;
+    y: number;
+    z: number;
+}): void;
+//# sourceMappingURL=m4_compose.d.ts.map

package/src/core/geom/3d/mat4/m4_compose.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"m4_compose.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/mat4/m4_compose.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,mCALW,MAAM,EAAE,GAAC,YAAY,OAAK;OACrB,MAAM;OAAI,MAAM;OAAI,MAAM;;OAC1B,MAAM;OAAI,MAAM;OAAI,MAAM;OAAI,MAAM;;OACpC,MAAM;OAAI,MAAM;OAAI,MAAM;SA+CzC"}

package/src/core/geom/3d/mat4/m4_compose.js

@@ -0,0 +1,53 @@
+/**
+ *
+ * @param {number[]|Float32Array|mat4} result
+ * @param { { x:number, y:number, z:number } } position
+ * @param { { x:number, y:number, z:number, w:number } } rotation
+ * @param { { x:number, y:number, z:number } } scale
+ */
+export function m4_compose(result, position, rotation, scale) {
+    const x = rotation.x;
+    const y = rotation.y;
+    const z = rotation.z;
+    const w = rotation.w;
+
+    const x2 = x + x;
+    const y2 = y + y;
+    const z2 = z + z;
+
+    const xx = x * x2;
+    const xy = x * y2;
+    const xz = x * z2;
+
+    const yy = y * y2;
+    const yz = y * z2;
+    const zz = z * z2;
+
+    const wx = w * x2;
+    const wy = w * y2;
+    const wz = w * z2;
+
+    const sx = scale.x;
+    const sy = scale.y;
+    const sz = scale.z;
+
+    result[0] = (1 - (yy + zz)) * sx;
+    result[1] = (xy + wz) * sx;
+    result[2] = (xz - wy) * sx;
+    result[3] = 0;
+
+    result[4] = (xy - wz) * sy;
+    result[5] = (1 - (xx + zz)) * sy;
+    result[6] = (yz + wx) * sy;
+    result[7] = 0;
+
+    result[8] = (xz + wy) * sz;
+    result[9] = (yz - wx) * sz;
+    result[10] = (1 - (xx + yy)) * sz;
+    result[11] = 0;
+
+    result[12] = position.x;
+    result[13] = position.y;
+    result[14] = position.z;
+    result[15] = 1;
+}

package/src/core/geom/3d/mat4/m4_compute_normal_matrix3.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @deprecated Renamed to {@link m4_normal_matrix3}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
+ */
+export const m4_compute_normal_matrix3: typeof m4_normal_matrix3;
+import { m4_normal_matrix3 } from "./m4_normal_matrix3.js";
+//# sourceMappingURL=m4_compute_normal_matrix3.d.ts.map

package/src/core/geom/3d/mat4/m4_compute_normal_matrix3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"m4_compute_normal_matrix3.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/mat4/m4_compute_normal_matrix3.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,iEAA2D;kCANzB,wBAAwB"}

package/src/core/geom/3d/mat4/m4_compute_normal_matrix3.js

@@ -0,0 +1,7 @@
+import { m4_normal_matrix3 } from "./m4_normal_matrix3.js";
+
+/**
+ * @deprecated Renamed to {@link m4_normal_matrix3}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
+ */
+export const m4_compute_normal_matrix3 = m4_normal_matrix3;

package/src/core/geom/3d/mat4/m4_decompose.d.ts

@@ -0,0 +1,9 @@
+/**
+ *
+ * @param {number[]} mat4
+ * @param {Vector3|{set(x:number,y:number,z:number)}} position
+ * @param {Quaternion} rotation
+ * @param {Vector3|{set(x:number,y:number,z:number)}} scale
+ */
+export function m4_decompose(mat4: number[], position: any, rotation: Quaternion, scale: any): void;
+//# sourceMappingURL=m4_decompose.d.ts.map

package/src/core/geom/3d/mat4/m4_decompose.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"m4_decompose.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/mat4/m4_decompose.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,mCALW,MAAM,EAAE,yDAuElB"}

package/src/core/geom/3d/mat4/m4_decompose.js

@@ -0,0 +1,76 @@
+import { v3_length } from "../../vec3/v3_length.js";
+
+/**
+ *
+ * @param {number[]} mat4
+ * @param {Vector3|{set(x:number,y:number,z:number)}} position
+ * @param {Quaternion} rotation
+ * @param {Vector3|{set(x:number,y:number,z:number)}} scale
+ */
+export function m4_decompose(mat4, position, rotation, scale) {
+    const m11 = mat4[0];
+    const m12 = mat4[1];
+    const m13 = mat4[2];
+
+    const scale_x = v3_length(m11, m12, m13);
+
+    const m21 = mat4[4];
+    const m22 = mat4[5];
+    const m23 = mat4[6];
+
+    const scale_y = v3_length(m21, m22, m23);
+
+    const m31 = mat4[8];
+    const m32 = mat4[9];
+    const m33 = mat4[10];
+
+    const scale_z = v3_length(m31, m32, m33);
+
+    // If the upper-left 3x3 has a negative determinant the matrix encodes a reflection; fold that sign into
+    // one scale axis (matching three.js, which negates scale.x) so the extracted rotation is a proper rotation
+    // rather than a mirror (which __setFromRotationMatrix would decode incorrectly).
+    const det =
+        m11 * (m22 * m33 - m23 * m32)
+        - m12 * (m21 * m33 - m23 * m31)
+        + m13 * (m21 * m32 - m22 * m31);
+
+    const signed_scale_x = det < 0 ? -scale_x : scale_x;
+
+    // extract rotation matrix
+    // take care of potential division by 0 when scale is 0. Result is inexact, but we get don't break the system at least
+    const is1 = signed_scale_x !== 0 ? 1 / signed_scale_x : 1e7;
+    const is2 = scale_y !== 0 ? 1 / scale_y : 1e7;
+    const is3 = scale_z !== 0 ? 1 / scale_z : 1e7;
+
+    const sm11 = m11 * is1;
+    const sm12 = m12 * is1;
+    const sm13 = m13 * is1;
+
+    const sm21 = m21 * is2;
+    const sm22 = m22 * is2;
+    const sm23 = m23 * is2;
+
+    const sm31 = m31 * is3;
+    const sm32 = m32 * is3;
+    const sm33 = m33 * is3;
+
+    // write out results
+
+    position.set(
+        mat4[12],
+        mat4[13],
+        mat4[14]
+    );
+
+    scale.set(
+        signed_scale_x,
+        scale_y,
+        scale_z
+    );
+
+    rotation.__setFromRotationMatrix(
+        sm11, sm21, sm31,
+        sm12, sm22, sm32,
+        sm13, sm23, sm33
+    );
+}

package/src/core/geom/3d/mat4/m4_euler_angles.d.ts

@@ -0,0 +1,33 @@
+/**
+ *
+ * returns the Euler-angles of the rotation matrix \c *this using the convention defined by the triplet (`a0`,`a1`,`a2`)
+ *
+ * Each of the three parameters `a0`, `a1`, `a2` represents the respective rotation axis as an integer in {0,1,2}.
+ * For instance, in:
+ * ```
+ * Vector3f ea = mat.eulerAngles(2, 0, 2);
+ * ```
+ * "2" represents the z axis and "0" the x axis, etc. The returned angles are such that
+ * we have the following equality:
+ * ```
+ * mat == AngleAxisf(ea[0], Vector3f::UnitZ())
+ *      * AngleAxisf(ea[1], Vector3f::UnitX())
+ *      * AngleAxisf(ea[2], Vector3f::UnitZ());
+ * ```
+ * This corresponds to the right-multiply conventions (with right hand side frames).
+ *
+ * The returned angles are in the ranges [0:pi]x[-pi:pi]x[-pi:pi].
+
+ * NOTE: ported from Eigen C++ library
+ *
+ * @see https://gitlab.com/libeigen/eigen/-/blob/master/Eigen/src/Geometry/EulerAngles.h
+ * @see https://stackoverflow.com/questions/11514063/extract-yaw-pitch-and-roll-from-a-rotationmatrix
+ *
+ * @param {number[]} output
+ * @param {number[]|Float32Array|mat4} m4 source matrix to extract rotation from
+ * @param {number} a0 axis index (0 = X, 1 = Y, 2 = Z)
+ * @param {number} a1 axis index
+ * @param {number} a2 axis index
+ */
+export function m4_euler_angles(output: number[], m4: number[] | Float32Array | mat4, a0: number, a1: number, a2: number): void;
+//# sourceMappingURL=m4_euler_angles.d.ts.map

package/src/core/geom/3d/mat4/m4_euler_angles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"m4_euler_angles.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/mat4/m4_euler_angles.js"],"names":[],"mappings":"AAmBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wCANW,MAAM,EAAE,MACR,MAAM,EAAE,GAAC,YAAY,OAAK,MAC1B,MAAM,MACN,MAAM,MACN,MAAM,QA2EhB"}

package/src/core/geom/3d/mat4/m4_euler_angles.js

@@ -0,0 +1,124 @@
+import { v2_length } from "../../vec2/v2_length.js";
+
+
+/**
+ *
+ * @param {number[]} mat4
+ * @param {number} row_index
+ * @param {number} column_index
+ * @return {number}
+ * @ignore
+ */
+function coeff(mat4, row_index, column_index) {
+    return mat4[row_index + column_index * 4];
+}
+
+const sin = Math.sin;
+const cos = Math.cos;
+const atan2 = Math.atan2;
+
+/**
+ *
+ * returns the Euler-angles of the rotation matrix \c *this using the convention defined by the triplet (`a0`,`a1`,`a2`)
+ *
+ * Each of the three parameters `a0`, `a1`, `a2` represents the respective rotation axis as an integer in {0,1,2}.
+ * For instance, in:
+ * ```
+ * Vector3f ea = mat.eulerAngles(2, 0, 2);
+ * ```
+ * "2" represents the z axis and "0" the x axis, etc. The returned angles are such that
+ * we have the following equality:
+ * ```
+ * mat == AngleAxisf(ea[0], Vector3f::UnitZ())
+ *      * AngleAxisf(ea[1], Vector3f::UnitX())
+ *      * AngleAxisf(ea[2], Vector3f::UnitZ());
+ * ```
+ * This corresponds to the right-multiply conventions (with right hand side frames).
+ *
+ * The returned angles are in the ranges [0:pi]x[-pi:pi]x[-pi:pi].
+
+ * NOTE: ported from Eigen C++ library
+ *
+ * @see https://gitlab.com/libeigen/eigen/-/blob/master/Eigen/src/Geometry/EulerAngles.h
+ * @see https://stackoverflow.com/questions/11514063/extract-yaw-pitch-and-roll-from-a-rotationmatrix
+ *
+ * @param {number[]} output
+ * @param {number[]|Float32Array|mat4} m4 source matrix to extract rotation from
+ * @param {number} a0 axis index (0 = X, 1 = Y, 2 = Z)
+ * @param {number} a1 axis index
+ * @param {number} a2 axis index
+ */
+export function m4_euler_angles(
+    output, m4,
+    a0, a1, a2
+) {
+
+    const odd = ((a0 + 1) % 3 === a1) ? 0 : 1;
+
+    const i = a0;
+    const j = (a0 + 1 + odd) % 3;
+    const k = (a0 + 2 - odd) % 3;
+
+    if (a0 === a2) {
+        output[0] = atan2(coeff(m4, j, i), coeff(m4, k, i));
+
+        if ((odd && output[0] < 0) || ((!odd) && output[0] > 0)) {
+            if (output[0] > 0) {
+                output[0] -= Math.PI;
+            } else {
+                output[0] += Math.PI;
+            }
+            const s2 = v2_length(coeff(m4, j, i), coeff(m4, k, i));
+            output[1] = -atan2(s2, coeff(m4, i, i));
+        } else {
+            const s2 = v2_length(coeff(m4, j, i), coeff(m4, k, i));
+            output[1] = atan2(s2, coeff(m4, i, i));
+        }
+
+        // With a=(0,1,0), we have i=0; j=1; k=2, and after computing the first two angles,
+        // we can compute their respective rotation, and apply its inverse to M. Since the result must
+        // be a rotation around x, we have:
+        //
+        //  c2  s1.s2 c1.s2                   1  0   0
+        //  0   c1    -s1       *    M    =   0  c3  s3
+        //  -s2 s1.c2 c1.c2                   0 -s3  c3
+        //
+        //  Thus:  m11.c1 - m21.s1 = c3  &   m12.c1 - m22.s1 = s3
+
+        const s1 = sin(output[0]);
+        const c1 = cos(output[0]);
+
+        output[2] = atan2(c1 * coeff(m4, j, k) - s1 * coeff(m4, k, k), c1 * coeff(m4, j, j) - s1 * coeff(m4, k, j));
+
+    } else {
+
+        output[0] = atan2(coeff(m4, j, k), coeff(m4, k, k));
+
+        const c2 = v2_length(coeff(m4, i, i), coeff(m4, i, j));
+
+        if ((odd && output[0] < 0) || ((!odd) && output[0] > 0)) {
+            if (output[0] > 0) {
+                output[0] -= Math.PI;
+            } else {
+                output[0] += Math.PI;
+            }
+            output[1] = atan2(-coeff(m4, i, k), -c2);
+        } else {
+            output[1] = atan2(-coeff(m4, i, k), c2);
+        }
+
+        const s1 = sin(output[0]);
+        const c1 = cos(output[0]);
+
+        output[2] = atan2(s1 * coeff(m4, k, i) - c1 * coeff(m4, j, i), c1 * coeff(m4, j, j) - s1 * coeff(m4, k, j));
+
+    }
+
+    if (odd === 0) {
+        // invert result
+        output[0] = -output[0];
+        output[1] = -output[1];
+        output[2] = -output[2];
+    }
+
+}

package/src/core/geom/3d/mat4/m4_normal_matrix3.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Compute the normal matrix (the matrix that correctly transforms surface normals) from the
+ * upper-left 3x3 of a 4x4 transform, using the transpose-adjugate (cofactor) method.
+ *
+ * The normal matrix is the transpose of the inverse of the linear part of the transform. The
+ * cofactor matrix equals `det(M) * (M^-1)^T`, so it points the same direction as the true normal
+ * matrix and avoids an explicit matrix inversion. The `det(M)` scale factor is irrelevant because
+ * the transformed normals must be re-normalized afterwards anyway.
+ *
+ * NOTE: the resulting matrix produces scaled (non-unit) vectors — normalize the output of any
+ * transform performed with it.
+ *
+ * @source Eric Lengyel, "Transforming Normals", 2024: https://terathon.com/blog/transforming-normals.html
+ * @source Ken Turkowski, "Properties of Surface Normal Transformations" (Graphics Gems, 1990)
+ *
+ * @param {number[]|Float32Array} out 9-element, column-major 3x3 matrix
+ * @param {number[]|Float32Array} m 16-element, column-major 4x4 matrix
+ */
+export function m4_normal_matrix3(out: number[] | Float32Array, m: number[] | Float32Array): void;
+//# sourceMappingURL=m4_normal_matrix3.d.ts.map

package/src/core/geom/3d/mat4/m4_normal_matrix3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"m4_normal_matrix3.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/mat4/m4_normal_matrix3.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,uCAHW,MAAM,EAAE,GAAC,YAAY,KACrB,MAAM,EAAE,GAAC,YAAY,QAsB/B"}

package/src/core/geom/3d/mat4/m4_normal_matrix3.js

@@ -0,0 +1,39 @@
+/**
+ * Compute the normal matrix (the matrix that correctly transforms surface normals) from the
+ * upper-left 3x3 of a 4x4 transform, using the transpose-adjugate (cofactor) method.
+ *
+ * The normal matrix is the transpose of the inverse of the linear part of the transform. The
+ * cofactor matrix equals `det(M) * (M^-1)^T`, so it points the same direction as the true normal
+ * matrix and avoids an explicit matrix inversion. The `det(M)` scale factor is irrelevant because
+ * the transformed normals must be re-normalized afterwards anyway.
+ *
+ * NOTE: the resulting matrix produces scaled (non-unit) vectors — normalize the output of any
+ * transform performed with it.
+ *
+ * @source Eric Lengyel, "Transforming Normals", 2024: https://terathon.com/blog/transforming-normals.html
+ * @source Ken Turkowski, "Properties of Surface Normal Transformations" (Graphics Gems, 1990)
+ *
+ * @param {number[]|Float32Array} out 9-element, column-major 3x3 matrix
+ * @param {number[]|Float32Array} m 16-element, column-major 4x4 matrix
+ */
+export function m4_normal_matrix3(out, m) {
+    // columns of the upper-left 3x3 (gl-matrix is column-major)
+    const c0_x = m[0], c0_y = m[1], c0_z = m[2];
+    const c1_x = m[4], c1_y = m[5], c1_z = m[6];
+    const c2_x = m[8], c2_y = m[9], c2_z = m[10];
+
+    // column 0 = cross(c1, c2)
+    out[0] = c1_y * c2_z - c1_z * c2_y;
+    out[1] = c1_z * c2_x - c1_x * c2_z;
+    out[2] = c1_x * c2_y - c1_y * c2_x;
+
+    // column 1 = cross(c2, c0)
+    out[3] = c2_y * c0_z - c2_z * c0_y;
+    out[4] = c2_z * c0_x - c2_x * c0_z;
+    out[5] = c2_x * c0_y - c2_y * c0_x;
+
+    // column 2 = cross(c0, c1)
+    out[6] = c0_y * c1_z - c0_z * c1_y;
+    out[7] = c0_z * c1_x - c0_x * c1_z;
+    out[8] = c0_x * c1_y - c0_y * c1_x;
+}

package/src/core/geom/3d/mat4/m4_transform_direction_v3_buffer.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Matrix-transform an array of 3d direction vectors
+ * Code is inlined for speed
+ * @param {number[]|Float32Array|Float64Array} source
+ * @param {number} source_offset
+ * @param {number[]|Float32Array|Float64Array} destination
+ * @param {number} destination_offset
+ * @param {number} vertex_count
+ * @param {mat4|number[]|Float32Array} mat4
+ */
+export function m4_transform_direction_v3_buffer(source: number[] | Float32Array | Float64Array, source_offset: number, destination: number[] | Float32Array | Float64Array, destination_offset: number, vertex_count: number, mat4: any): void;
+//# sourceMappingURL=m4_transform_direction_v3_buffer.d.ts.map

package/src/core/geom/3d/mat4/m4_transform_direction_v3_buffer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"m4_transform_direction_v3_buffer.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/mat4/m4_transform_direction_v3_buffer.js"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,yDAPW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,eACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,sBAClC,MAAM,gBACN,MAAM,mBA6ChB"}