@woosh/meep-engine 2.33.71 → 2.33.72

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/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

@@ -8,13 +8,14 @@ import { assert } from "../../../../../core/assert.js";
 import { lerp } from "../../../../../core/math/lerp.js";
 import { Euler, Matrix4 } from "three";
 import { normalize_angle_rad } from "../../../../../core/geom/normalize_angle_rad.js";
-import { eulerAnglesFromMatrix } from "../../../../../core/geom/3d/eulerAnglesFromMatrix.js";
+import { v3_angle_between_atan2 } from "../../../../../core/geom/v3_angle_between.js";
 
 const m4 = new Matrix4();
 const euler = new Euler();
 
 const panOffset = new Vector3();
 
+
 /**
  *
  * @param {number} displacement_x
@@ -122,37 +123,74 @@ class TopDownCameraController {
      * @param {Vector3} [up]
      */
     setFromEyeAndTarget(eye, target, up = Vector3.up) {
+        /**
+         * ----
+         * float projectOnPlane(Vector3 a, Vector3 b) {
+         *       Vector3 bProjection = (Vector3.Dot(a, b) / b.Length) * (b / b.Length);
+         *       return a - bProjection;
+         *  }
+         * ----
+         * @see https://gamedev.stackexchange.com/questions/134354/gravity-vector-and-forward-vector-to-local-heading-yaw-pitch-and-roll
+         * @param {Vector3} a
+         * @param {Vector3} b
+         */
+        function projectOnPlane(a, b) {
+            const i = a.dot(b) / b.length();
+            const j = new Vector3();
+            j.copy(b);
+            j.normalize();
+
+            j.multiplyScalar(i);
+
+            j.subVectors(a, j);
+
+            return j;
+        }
+
+        function pitch(direction, gravity) {
+            const heading = projectOnPlane(direction, gravity);
+
+            return v3_angle_between_atan2(
+                direction.x, direction.y, direction.z,
+                heading.x, heading.y, heading.z
+            )
+        }
+
+        function yaw(direction, gravity, north) {
+            const heading = projectOnPlane(direction, gravity);
+
+            return v3_angle_between_atan2(
+                heading.x, heading.y, heading.z,
+                north.x, north.y, north.z,
+            );
+        }
+
+
+        // extract pitch and yaw only
+        const view_vector = new Vector3();
+        view_vector.subVectors(eye, target);
+
+
+        const _p3 = pitch(view_vector, up);
+        const _y3 = yaw(view_vector, up, Vector3.back);
+
         /*
         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');
 
-        const angles = [];
-        eulerAnglesFromMatrix(angles, m4.elements, 2, 1, 0);
 
         const _p0 = normalize_angle_rad(euler.x);
         const _y0 = normalize_angle_rad(euler.y);
         const _r0 = normalize_angle_rad(euler.z);
 
-        this.pitch = _p0;
-        this.yaw = _y0;
-        this.roll = _r0;
-
-
-        const _p1 = angles[2];
-        const _y1 = angles[1];
-        const _r1 = angles[0];
-
-        if (_p0 !== _p0 || _y0 !== _y1 || _r0 !== _r1) {
-            console.warn('Angular discrepancy');
-        }
-
-        this.pitch = _p1;
-        this.yaw = _y1;
-        this.roll = _r1;
+        this.pitch = _p3;
+        this.yaw = _y3;
+        this.roll = 0;
 
         this.distance = eye.distanceTo(target);
 

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.71",
+  "version": "2.33.72",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",