@woosh/meep-engine 2.33.70 → 2.33.74

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

@@ -0,0 +1,115 @@
+//
+
+import { v2_magnitude } from "../Vector2.js";
+
+function atan2(a, b) {
+    return Math.atan2(a, b);
+}
+
+/**
+ *
+ * @param {number[]} mat4
+ * @param {number} row_index
+ * @param {number} column_index
+ * @return {number}
+ */
+function coeff(mat4, row_index, column_index) {
+    return mat4[row_index + column_index * 4];
+}
+
+function sin(a) {
+    return Math.sin(a);
+}
+
+function cos(a) {
+    return Math.cos(a);
+}
+
+const EIGEN_PI = Math.PI;
+
+/**
+ *
+ * \returns the Euler-angles of the rotation matrix \c *this using the convention defined by the triplet (\a a0,\a a1,\a a2)
+ *
+ * Each of the three parameters \a a0,\a a1,\a a2 represents the respective rotation axis as an integer in {0,1,2}.
+ * For instance, in:
+ * \code Vector3f ea = mat.eulerAngles(2, 0, 2); \endcode
+ * "2" represents the z axis and "0" the x axis, etc. The returned angles are such that
+ * we have the following equality:
+ * \code
+ * mat == AngleAxisf(ea[0], Vector3f::UnitZ())
+ *      * AngleAxisf(ea[1], Vector3f::UnitX())
+ *      * AngleAxisf(ea[2], Vector3f::UnitZ()); \endcode
+ * 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[]} res
+ * @param {number[]|Float32Array|mat4} m4
+ * @param {number} a0 axis index
+ * @param {number} a1
+ * @param {number} a2
+ */
+export function eulerAnglesFromMatrix(res, 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) {
+        res[0] = atan2(coeff(m4, j, i), coeff(m4, k, i));
+        if ((odd && res[0] < 0) || ((!odd) && res[0] > 0)) {
+            if (res[0] > 0) {
+                res[0] -= EIGEN_PI;
+            } else {
+                res[0] += EIGEN_PI;
+            }
+            const s2 = v2_magnitude(coeff(m4, j, i), coeff(m4, k, i));
+            res[1] = -atan2(s2, coeff(m4, i, i));
+        } else {
+            const s2 = v2_magnitude(coeff(m4, j, i), coeff(m4, k, i));
+            res[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(res[0]);
+        const c1 = cos(res[0]);
+        res[2] = atan2(c1 * coeff(m4, j, k) - s1 * coeff(m4, k, k), c1 * coeff(m4, j, j) - s1 * coeff(m4, k, j));
+    } else {
+        res[0] = atan2(coeff(m4, j, k), coeff(m4, k, k));
+        const c2 = v2_magnitude(coeff(m4, i, i), coeff(m4, i, j));
+        if ((odd && res[0] < 0) || ((!odd) && res[0] > 0)) {
+            if (res[0] > 0) {
+                res[0] -= EIGEN_PI;
+            } else {
+                res[0] += EIGEN_PI;
+            }
+            res[1] = atan2(-coeff(m4, i, k), -c2);
+        } else
+            res[1] = atan2(-coeff(m4, i, k), c2);
+        const s1 = sin(res[0]);
+        const c1 = cos(res[0]);
+        res[2] = atan2(s1 * coeff(m4, k, i) - c1 * coeff(m4, j, i), c1 * coeff(m4, j, j) - s1 * coeff(m4, k, j));
+    }
+
+    if (!odd) {
+        // invert result
+        res[0] = -res[0];
+        res[1] = -res[1];
+        res[2] = -res[2];
+    }
+
+}

package/core/geom/3d/topology/TopoMesh.js

@@ -482,7 +482,7 @@ export class TopoMesh {
         assert.equal(a.isTopoVertex, true, 'a.isTopoVertex !== true');
         assert.equal(b.isTopoVertex, true, 'b.isTopoVertex !== true');
 
-        assert.notEqual(a, b, 'a === b, attempting to create an edge from vertex to itself')
+        assert.notEqual(a, b, 'a === b, attempting to create an edge from vertex to itself');
 
         const aEdges = a.edges;
         const n = aEdges.length;

package/core/geom/Vector3.js

@@ -11,7 +11,7 @@ import { sign } from "../math/sign.js";
 import { v3_dot } from "./v3_dot.js";
 import { v3_length_sqr } from "./v3_length_sqr.js";
 import { v3_length } from "./v3_length.js";
-import { v3_angle_between } from "./v3_angle_between.js";
+import { v3_angle_between, v3_angle_between_atan2 } from "./v3_angle_between.js";
 import { v3_lerp } from "./v3_lerp.js";
 import { v3_slerp } from "./v3_slerp.js";
 import { computeHashFloat } from "../math/hash/computeHashFloat.js";
@@ -448,7 +448,7 @@ class Vector3 {
      * @returns {number}
      */
     angleTo(other) {
-        return v3_angle_between(this.x, this.y, this.z, other.x, other.y, other.z);
+        return v3_angle_between_atan2(this.x, this.y, this.z, other.x, other.y, other.z);
     }
 
     /**

package/core/geom/normalize_angle_rad.js

@@ -0,0 +1,18 @@
+import { PI2 } from "../math/MathUtils.js";
+
+/**
+ * Force angle to [-PI, +PI] range
+ * based on answer https://stackoverflow.com/a/2323034/3973586
+ * @param {number} angle in radians
+ * @return {number} in radians
+ */
+export function normalize_angle_rad(angle) {
+    let r = angle % PI2;
+    r = (r + PI2) % PI2;
+
+    if (r > Math.PI) {
+        r -= PI2;
+    }
+
+    return r;
+}

package/core/geom/normalize_angle_rad.spec.js

@@ -0,0 +1,45 @@
+import { normalize_angle_rad } from "./normalize_angle_rad.js";
+
+test('0', () => {
+    expect(normalize_angle_rad(0)).toBe(0);
+});
+
+test('PI', () => {
+    expect(normalize_angle_rad(Math.PI)).toBe(Math.PI);
+});
+
+test('-PI', () => {
+    expect(normalize_angle_rad(-Math.PI)).toBeCloseTo(Math.PI);
+});
+
+test('2*PI', () => {
+    expect(normalize_angle_rad(Math.PI * 2)).toBeCloseTo(0);
+});
+
+test('-2*PI', () => {
+    expect(normalize_angle_rad(-Math.PI * 2)).toBeCloseTo(0);
+});
+
+test('-1', () => {
+    expect(normalize_angle_rad(-1)).toBeCloseTo(-1);
+});
+
+test('-3', () => {
+    expect(normalize_angle_rad(-3)).toBeCloseTo(-3);
+});
+
+test('1', () => {
+    expect(normalize_angle_rad(1)).toBeCloseTo(1);
+});
+
+test('3', () => {
+    expect(normalize_angle_rad(3)).toBeCloseTo(3);
+});
+
+test('2*PI + 1', () => {
+    expect(normalize_angle_rad(Math.PI * 2 + 1)).toBeCloseTo(1);
+});
+
+test('- ( 2*PI + 1)', () => {
+    expect(normalize_angle_rad(-(Math.PI * 2 + 1))).toBeCloseTo(-1);
+});

package/core/geom/v3_angle_between.js

@@ -29,3 +29,25 @@ export function v3_angle_between(x0, y0, z0, x1, y1, z1) {
 
     return Math.acos(theta);
 }
+
+/**
+ *
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @returns {number}
+ */
+export function v3_angle_between_atan2(x0, y0, z0, x1, y1, z1) {
+    const cx = y0 * z1 - z0 * y1;
+    const cy = z0 * x1 - x0 * z1;
+    const cz = x0 * y1 - y0 * x1;
+
+    const cross_length = v3_length(cx, cy, cz);
+
+    const d = v3_dot(x0, y0, z0, x1, y1, z1);
+
+    return Math.atan2(cross_length, d);
+}

package/engine/graphics/ecs/camera/topdown/TopDownCameraController.js

@@ -7,29 +7,15 @@ import Vector3 from '../../../../../core/geom/Vector3.js';
 import { assert } from "../../../../../core/assert.js";
 import { lerp } from "../../../../../core/math/lerp.js";
 import { Euler, Matrix4 } from "three";
-import { PI2 } from "../../../../../core/math/MathUtils.js";
+import { normalize_angle_rad } from "../../../../../core/geom/normalize_angle_rad.js";
+import { eulerAnglesFromMatrix } from "../../../../../core/geom/3d/eulerAnglesFromMatrix.js";
 
 const m4 = new Matrix4();
 const euler = new Euler();
+const angles = [];
 
 const panOffset = new Vector3();
 
-/**
- * Force angle to [-PI, +PI] range
- * based on answer https://stackoverflow.com/a/2323034/3973586
- * @param {number} angle in radians
- * @return {number} in radians
- */
-function normalize_angle(angle) {
-    let r = angle % PI2;
-    r = (r + PI2) % PI2;
-
-    if (r > Math.PI) {
-        r -= PI2;
-    }
-
-    return r;
-}
 
 /**
  *
@@ -40,11 +26,14 @@ function normalize_angle(angle) {
  */
 export function rotate_from_view(displacement_x, displacement_y, input, output) {
     // crop yaw and pitch to safe range of -PI to PI
-    const i_pitch = normalize_angle(input.pitch);
-    const i_yaw = normalize_angle(input.yaw);
+    const i_pitch = normalize_angle_rad(input.pitch);
+    const i_yaw = normalize_angle_rad(input.yaw);
+    const i_roll = normalize_angle_rad(input.roll);
+
+    const d_roll = (i_roll >= Math.PI || i_roll <= -Math.PI) ? -1 : 1;
 
     // flip rotation axis when pitch is over 90deg in either direction, that is UP vector is pointing down
-    const d_yaw = ((i_pitch > Math.PI || i_pitch < -Math.PI) ? -1 : 1) * displacement_x;
+    const d_yaw = d_roll * ((i_pitch > Math.PI || i_pitch < -Math.PI) ? -1 : 1) * displacement_x;
 
     output.yaw = i_yaw + d_yaw;
     output.pitch = i_pitch - displacement_y;
@@ -138,17 +127,18 @@ class TopDownCameraController {
      * @param {Vector3} [up]
      */
     setFromEyeAndTarget(eye, target, up = Vector3.up) {
+
         /*
         NOTE: I'm not sure why, but three.js camera points in the opposite direction to normal objects
         See: https://github.com/mrdoob/three.js/blob/412b99a7f26e117ea97f40eb53d010ab81aa3279/src/core/Object3D.js#L282
          */
         m4.lookAt(target, eye, up);
 
-        euler.setFromRotationMatrix(m4, 'ZYX');
+        eulerAnglesFromMatrix(angles, m4.elements, 2, 1, 0)
 
-        this.pitch = normalize_angle(euler.x);
-        this.yaw = normalize_angle(euler.y);
-        this.roll = normalize_angle(euler.z);
+        this.pitch = angles[2];
+        this.yaw = angles[1];
+        this.roll = angles[0];
 
         this.distance = eye.distanceTo(target);
 

package/engine/graphics/ecs/camera/topdown/TopDownCameraController.spec.js

@@ -11,6 +11,15 @@ test('setFromEyeAndTarget does not introduce roll when UP is aligned with +Y', (
     expect(ut.roll).toBe(0);
 });
 
+test('setFromEyeAndTarget, with different directional axial combinations', () => {
+    const ut = new TopDownCameraController();
+
+    ut.setFromEyeAndTarget(new Vector3(0, 1, -1), new Vector3(0, 0, 0), new Vector3(0, 1, 0));
+    ut.setFromEyeAndTarget(new Vector3(0, 1, -1), new Vector3(0, 0, 0), new Vector3(0, 1, 0));
+
+    expect(ut.roll).toBe(0);
+});
+
 test('setFromEyeAndTarget results in roll respecting UP vector', () => {
     const eye = new Vector3();
     const target = new Vector3();

package/package.json

@@ -5,7 +5,7 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.33.70",
+  "version": "2.33.74",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",