littlejsengine 1.19.3 → 1.20.0

package/plugins/math3d.js

@@ -288,6 +288,7 @@ class Vector3
 
 // scratch for multiply, nothing keeps a reference to it
 const matrix4Scratch = new Float32Array(16);
+const matrix4Identity = new Float32Array([1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1]);
 
 /**
  * 4x4 transform matrix for moving, rotating and scaling points in 3D
@@ -330,22 +331,23 @@ class Matrix4
         return r;
     }
 
-    /** Returns a new rotation matrix, rolled first, then pitched, then yawed
+    /** Returns a rotation matrix, rolled first, then pitched, then yawed
      *  @param {Vector3} euler - vec3(pitch, yaw, roll) in radians
+     *  @param {Matrix4} [matrix] - Written into instead of a new one, for a loop that builds many
      *  @return {Matrix4} */
-    static rotation(euler)
+    static rotation(euler, matrix=new Matrix4)
     {
         ASSERT_VECTOR3_VALID(euler);
         const cx = cos(euler.x), sx = sin(euler.x);
         const cy = cos(euler.y), sy = sin(euler.y);
         const cz = cos(euler.z), sz = sin(euler.z);
-        const r = new Matrix4;
-        const m = r.m;
-        // R = Ry * Rx * Rz written out, column major
-        m[0] = cy*cz + sy*sx*sz;  m[1] = cx*sz;  m[2]  = -sy*cz + cy*sx*sz;
-        m[4] = -cy*sz + sy*sx*cz; m[5] = cx*cz;  m[6]  = sy*sz + cy*sx*cz;
-        m[8] = sy*cx;             m[9] = -sx;    m[10] = cy*cx;
-        return r;
+        const m = matrix.m;
+        // R = Ry * Rx * Rz written out, column major, every element set so a reused matrix comes out clean
+        m[0] = cy*cz + sy*sx*sz;  m[1] = cx*sz;  m[2]  = -sy*cz + cy*sx*sz; m[3] = 0;
+        m[4] = -cy*sz + sy*sx*cz; m[5] = cx*cz;  m[6]  = sy*sz + cy*sx*cz;  m[7] = 0;
+        m[8] = sy*cx;             m[9] = -sx;    m[10] = cy*cx;             m[11] = 0;
+        m[12] = m[13] = m[14] = 0; m[15] = 1;
+        return matrix;
     }
 
     /** Returns a new scale matrix
@@ -416,8 +418,10 @@ class Matrix4
         if (!z.lengthSquared())
             z = vec3(0, 0, 1); // eye is on the target, face -Z
         let x = up.cross(z).normalize();
-        if (!x.lengthSquared()) // up is along the view direction, pick another
-            x = (abs(z.y) > .99 ? vec3(0, 0, 1) : vec3(0, 1, 0)).cross(z).normalize();
+        // up is along the view direction, pick another; looking straight down or up keeps +X as the right axis,
+        // as three.js does and as a view tilting there from the +Z side ends up
+        if (!x.lengthSquared())
+            x = (abs(z.y) > .99 ? vec3(0, 0, z.y > 0 ? -1 : 1) : vec3(0, 1, 0)).cross(z).normalize();
         const y = z.cross(x);
         return new Matrix4([x.x, x.y, x.z, 0,  y.x, y.y, y.z, 0,  z.x, z.y, z.z, 0,  eye.x, eye.y, eye.z, 1]);
     }
@@ -530,6 +534,41 @@ class Matrix4
      *  @return {Vector3} */
     getTranslation() { return new Vector3(this.m[12], this.m[13], this.m[14]); }
 
+    /** Returns the determinant of the rotation and scale part: negative when the matrix mirrors, 0 when it flattens a
+     *  shape and has no inverse
+     *  @return {number} */
+    determinant()
+    {
+        const m = this.m;
+        return m[0]*(m[5]*m[10] - m[6]*m[9]) - m[4]*(m[1]*m[10] - m[2]*m[9]) + m[8]*(m[1]*m[6] - m[2]*m[5]);
+    }
+
+    /** Returns the scale part of this matrix, the length of each axis; a mirroring matrix shows as a negative x
+     *  @return {Vector3} */
+    getScale()
+    {
+        const m = this.m;
+        const x = hypot(m[0], m[1], m[2]), y = hypot(m[4], m[5], m[6]), z = hypot(m[8], m[9], m[10]);
+        return new Vector3(this.determinant() < 0 ? -x : x, y, z);
+    }
+
+    /** Returns the rotation part of this matrix as vec3(pitch, yaw, roll), the angles Matrix4.rotation builds it from
+     *  - The scale is divided out first, so it works on a full transform
+     *  - A matrix with shear, from a scaled parent with a turned child, has no exact answer and gets the nearest
+     *  @return {Vector3} */
+    getRotation()
+    {
+        // the axes at unit length, see Matrix4.rotation for which element is which
+        const m = this.m, s = this.getScale();
+        const sx = s.x || 1, sy = s.y || 1, sz = s.z || 1;
+        const m1 = m[1] / sx, m5 = m[5] / sy, m8 = m[8] / sz, m9 = m[9] / sz, m10 = m[10] / sz;
+        const pitch = Math.asin(clamp(-m9, -1, 1));
+        if (abs(m9) < 1 - 1e-6)
+            return new Vector3(pitch, atan2(m8, m10), atan2(m1, m5));
+        // straight up or down: yaw and roll turn about the same axis, so the roll is zero and yaw takes it all
+        return new Vector3(pitch, atan2(m[4] / sy * -m9, m[0] / sx), 0);
+    }
+
     /** Returns a string representation of this matrix for debugging
      *  @return {string} */
     toString()
@@ -550,18 +589,20 @@ class Matrix4
  * @param {Vector3} [pos]
  * @param {Vector3} [rotation] - vec3(pitch, yaw, roll) in radians
  * @param {Vector3} [scale]
+ * @param {Matrix4} [matrix] - Written into instead of a new one, for a loop that builds many
  * @return {Matrix4}
  * @memberof Math3D
  */
-function buildMatrix(pos, rotation, scale)
+function buildMatrix(pos, rotation, scale, matrix=new Matrix4)
 {
     ASSERT(!pos || isVector3(pos), 'pos must be a Vector3', pos);
     ASSERT(!scale || isVector3(scale), 'scale must be a Vector3', scale);
+    ASSERT(matrix instanceof Matrix4, 'the matrix to write into must be a Matrix4');
     // scale the rotation columns and drop the position in, instead of multiplying three matrices
     // an object that is not turned at all is most of a big scene, and identity is what the six
     // trig calls would have worked out to anyway
-    const turned = rotation && (rotation.x || rotation.y || rotation.z);
-    const matrix = turned ? Matrix4.rotation(rotation) : new Matrix4, m = matrix.m;
+    const turned = rotation && (rotation.x || rotation.y || rotation.z), m = matrix.m;
+    turned ? Matrix4.rotation(rotation, matrix) : m.set(matrix4Identity);
     if (scale)
     {
         m[0] *= scale.x; m[1] *= scale.x; m[2]  *= scale.x;
@@ -798,12 +839,12 @@ function raycastSphere(ray, pos, radius)
 {
     const {origin, direction} = ray;
     const oc = origin.subtract(pos);
+    const c = oc.dot(oc) - radius*radius;
+    if (c < 0)
+        return 0; // origin is inside the sphere, even for a ray of no length, as raycastBox gives
     const a = direction.dot(direction);
     if (!a)
         return undefined;
-    const c = oc.dot(oc) - radius*radius;
-    if (c < 0)
-        return 0; // origin is inside the sphere
     const b = 2*oc.dot(direction);
     const discriminant = b*b - 4*a*c;
     if (discriminant < 0)