@woosh/meep-engine 2.84.8 → 2.84.9

package/build/meep.cjs

@@ -2640,35 +2640,32 @@ let Vector3$1 = class Vector3 {
 
     /**
      *
-     * @param {ArrayList<number>|number[]|Float32Array} m4
+     * @param {ArrayLike<number>|number[]|Float32Array} m4
      */
     applyMatrix4(m4) {
         const x = this.x;
         const y = this.y;
         const z = this.z;
 
-        const _x = m4[0] * x + m4[4] * y + m4[8] * z + m4[12];
-        const _y = m4[1] * x + m4[5] * y + m4[9] * z + m4[13];
-        const _z = m4[2] * x + m4[6] * y + m4[10] * z + m4[14];
+        const w = 1 / (m4[3] * x + m4[7] * y + m4[11] * z + m4[15]);
+
+        const _x = (m4[0] * x + m4[4] * y + m4[8] * z + m4[12])* w;
+        const _y = (m4[1] * x + m4[5] * y + m4[9] * z + m4[13])* w;
+        const _z = (m4[2] * x + m4[6] * y + m4[10] * z + m4[14])* w;
 
         this.set(_x, _y, _z);
     }
 
     /**
      * Assume current vector holds a direction, transform using a matrix to produce a new directional unit vector
-     * @param {THREE.Matrix4} m
+     * @param {ArrayLike<number>|number[]|Float32Array} m4
      */
-    transformDirection_three(m) {
-
-        // input: THREE.Matrix4 affine matrix
-        // vector interpreted as a direction
-
+    applyDirectionMatrix4(m4){
         const x = this.x, y = this.y, z = this.z;
-        const e = m.elements;
 
-        const _x = e[0] * x + e[4] * y + e[8] * z;
-        const _y = e[1] * x + e[5] * y + e[9] * z;
-        const _z = e[2] * x + e[6] * y + e[10] * z;
+        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;
 
         // normalize the result
         const _l = 1 / v3_length(_x, _y, _z);
@@ -2680,6 +2677,20 @@ let Vector3$1 = class Vector3 {
         );
     }
 
+    /**
+     * @deprecated use non-three.js version instead
+     * @param {THREE.Matrix4} m
+     */
+    transformDirection_three(m) {
+
+        // input: THREE.Matrix4 affine matrix
+        // vector interpreted as a direction
+
+        const e = m.elements;
+
+        this.applyDirectionMatrix4(e);
+    }
+
     /**
      *
      * @param {THREE.Matrix3} m
@@ -4743,7 +4754,7 @@ class Transform {
     get forward() {
         const result = Vector3$1.forward.clone();
 
-        result.applyMatrix4(this.matrix);
+        result.applyDirectionMatrix4(this.matrix);
 
         return result;
     }
@@ -47191,44 +47202,8 @@ class SurfacePoint3 {
      */
     applyMatrix4(m) {
 
-        // transform position
-        const p = this.position;
-
-        const p_x = p.x;
-        const p_y = p.y;
-        const p_z = p.z;
-
-        // compute perspective projection
-        const w = 1 / (m[3] * p_x + m[7] * p_y + m[11] * p_z + m[15]);
-
-        const result_p_x = (m[0] * p_x + m[4] * p_y + m[8] * p_z + m[12]) * w;
-        const result_p_y = (m[1] * p_x + m[5] * p_y + m[9] * p_z + m[13]) * w;
-        const result_p_z = (m[2] * p_x + m[6] * p_y + m[10] * p_z + m[14]) * w;
-
-        p.set(
-            result_p_x,
-            result_p_y,
-            result_p_z
-        );
-
-        // transform normal
-        const n = this.normal;
-
-        const n_x = n.x;
-        const n_y = n.y;
-        const n_z = n.z;
-
-        const result_n_x = m[0] * n_x + m[4] * n_y + m[8] * n_z;
-        const result_n_y = m[1] * n_x + m[5] * n_y + m[9] * n_z;
-        const result_n_z = m[2] * n_x + m[6] * n_y + m[10] * n_z;
-
-        const normal_multiplier = 1 / v3_length(result_n_x, result_n_y, result_n_z);
-
-        n.set(
-            result_n_x * normal_multiplier,
-            result_n_y * normal_multiplier,
-            result_n_z * normal_multiplier,
-        );
+        this.position.applyMatrix4(m);
+        this.normal.applyDirectionMatrix4(m);
     }
 
     /**