|
|
@@ -12142,7 +12142,7 @@ class Matrix4 {
|
|
|
*/
|
|
|
invert() {
|
|
|
|
|
|
- // based on http://www.euclideanspace.com/maths/algebra/matrix/functions/inverse/fourD/index.htm
|
|
|
+ // based on https://github.com/toji/gl-matrix
|
|
|
const te = this.elements,
|
|
|
|
|
|
n11 = te[ 0 ], n21 = te[ 1 ], n31 = te[ 2 ], n41 = te[ 3 ],
|
|
|
@@ -12150,36 +12150,44 @@ class Matrix4 {
|
|
|
n13 = te[ 8 ], n23 = te[ 9 ], n33 = te[ 10 ], n43 = te[ 11 ],
|
|
|
n14 = te[ 12 ], n24 = te[ 13 ], n34 = te[ 14 ], n44 = te[ 15 ],
|
|
|
|
|
|
- t11 = n23 * n34 * n42 - n24 * n33 * n42 + n24 * n32 * n43 - n22 * n34 * n43 - n23 * n32 * n44 + n22 * n33 * n44,
|
|
|
- t12 = n14 * n33 * n42 - n13 * n34 * n42 - n14 * n32 * n43 + n12 * n34 * n43 + n13 * n32 * n44 - n12 * n33 * n44,
|
|
|
- t13 = n13 * n24 * n42 - n14 * n23 * n42 + n14 * n22 * n43 - n12 * n24 * n43 - n13 * n22 * n44 + n12 * n23 * n44,
|
|
|
- t14 = n14 * n23 * n32 - n13 * n24 * n32 - n14 * n22 * n33 + n12 * n24 * n33 + n13 * n22 * n34 - n12 * n23 * n34;
|
|
|
-
|
|
|
- const det = n11 * t11 + n21 * t12 + n31 * t13 + n41 * t14;
|
|
|
+ t1 = n11 * n22 - n21 * n12,
|
|
|
+ t2 = n11 * n32 - n31 * n12,
|
|
|
+ t3 = n11 * n42 - n41 * n12,
|
|
|
+ t4 = n21 * n32 - n31 * n22,
|
|
|
+ t5 = n21 * n42 - n41 * n22,
|
|
|
+ t6 = n31 * n42 - n41 * n32,
|
|
|
+ t7 = n13 * n24 - n23 * n14,
|
|
|
+ t8 = n13 * n34 - n33 * n14,
|
|
|
+ t9 = n13 * n44 - n43 * n14,
|
|
|
+ t10 = n23 * n34 - n33 * n24,
|
|
|
+ t11 = n23 * n44 - n43 * n24,
|
|
|
+ t12 = n33 * n44 - n43 * n34;
|
|
|
+
|
|
|
+ const det = t1 * t12 - t2 * t11 + t3 * t10 + t4 * t9 - t5 * t8 + t6 * t7;
|
|
|
|
|
|
if ( det === 0 ) return this.set( 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 );
|
|
|
|
|
|
const detInv = 1 / det;
|
|
|
|
|
|
- te[ 0 ] = t11 * detInv;
|
|
|
- te[ 1 ] = ( n24 * n33 * n41 - n23 * n34 * n41 - n24 * n31 * n43 + n21 * n34 * n43 + n23 * n31 * n44 - n21 * n33 * n44 ) * detInv;
|
|
|
- te[ 2 ] = ( n22 * n34 * n41 - n24 * n32 * n41 + n24 * n31 * n42 - n21 * n34 * n42 - n22 * n31 * n44 + n21 * n32 * n44 ) * detInv;
|
|
|
- te[ 3 ] = ( n23 * n32 * n41 - n22 * n33 * n41 - n23 * n31 * n42 + n21 * n33 * n42 + n22 * n31 * n43 - n21 * n32 * n43 ) * detInv;
|
|
|
+ te[ 0 ] = ( n22 * t12 - n32 * t11 + n42 * t10 ) * detInv;
|
|
|
+ te[ 1 ] = ( n31 * t11 - n21 * t12 - n41 * t10 ) * detInv;
|
|
|
+ te[ 2 ] = ( n24 * t6 - n34 * t5 + n44 * t4 ) * detInv;
|
|
|
+ te[ 3 ] = ( n33 * t5 - n23 * t6 - n43 * t4 ) * detInv;
|
|
|
|
|
|
- te[ 4 ] = t12 * detInv;
|
|
|
- te[ 5 ] = ( n13 * n34 * n41 - n14 * n33 * n41 + n14 * n31 * n43 - n11 * n34 * n43 - n13 * n31 * n44 + n11 * n33 * n44 ) * detInv;
|
|
|
- te[ 6 ] = ( n14 * n32 * n41 - n12 * n34 * n41 - n14 * n31 * n42 + n11 * n34 * n42 + n12 * n31 * n44 - n11 * n32 * n44 ) * detInv;
|
|
|
- te[ 7 ] = ( n12 * n33 * n41 - n13 * n32 * n41 + n13 * n31 * n42 - n11 * n33 * n42 - n12 * n31 * n43 + n11 * n32 * n43 ) * detInv;
|
|
|
+ te[ 4 ] = ( n32 * t9 - n12 * t12 - n42 * t8 ) * detInv;
|
|
|
+ te[ 5 ] = ( n11 * t12 - n31 * t9 + n41 * t8 ) * detInv;
|
|
|
+ te[ 6 ] = ( n34 * t3 - n14 * t6 - n44 * t2 ) * detInv;
|
|
|
+ te[ 7 ] = ( n13 * t6 - n33 * t3 + n43 * t2 ) * detInv;
|
|
|
|
|
|
- te[ 8 ] = t13 * detInv;
|
|
|
- te[ 9 ] = ( n14 * n23 * n41 - n13 * n24 * n41 - n14 * n21 * n43 + n11 * n24 * n43 + n13 * n21 * n44 - n11 * n23 * n44 ) * detInv;
|
|
|
- te[ 10 ] = ( n12 * n24 * n41 - n14 * n22 * n41 + n14 * n21 * n42 - n11 * n24 * n42 - n12 * n21 * n44 + n11 * n22 * n44 ) * detInv;
|
|
|
- te[ 11 ] = ( n13 * n22 * n41 - n12 * n23 * n41 - n13 * n21 * n42 + n11 * n23 * n42 + n12 * n21 * n43 - n11 * n22 * n43 ) * detInv;
|
|
|
+ te[ 8 ] = ( n12 * t11 - n22 * t9 + n42 * t7 ) * detInv;
|
|
|
+ te[ 9 ] = ( n21 * t9 - n11 * t11 - n41 * t7 ) * detInv;
|
|
|
+ te[ 10 ] = ( n14 * t5 - n24 * t3 + n44 * t1 ) * detInv;
|
|
|
+ te[ 11 ] = ( n23 * t3 - n13 * t5 - n43 * t1 ) * detInv;
|
|
|
|
|
|
- te[ 12 ] = t14 * detInv;
|
|
|
- te[ 13 ] = ( n13 * n24 * n31 - n14 * n23 * n31 + n14 * n21 * n33 - n11 * n24 * n33 - n13 * n21 * n34 + n11 * n23 * n34 ) * detInv;
|
|
|
- te[ 14 ] = ( n14 * n22 * n31 - n12 * n24 * n31 - n14 * n21 * n32 + n11 * n24 * n32 + n12 * n21 * n34 - n11 * n22 * n34 ) * detInv;
|
|
|
- te[ 15 ] = ( n12 * n23 * n31 - n13 * n22 * n31 + n13 * n21 * n32 - n11 * n23 * n32 - n12 * n21 * n33 + n11 * n22 * n33 ) * detInv;
|
|
|
+ te[ 12 ] = ( n22 * t8 - n12 * t10 - n32 * t7 ) * detInv;
|
|
|
+ te[ 13 ] = ( n11 * t10 - n21 * t8 + n31 * t7 ) * detInv;
|
|
|
+ te[ 14 ] = ( n24 * t2 - n14 * t4 - n34 * t1 ) * detInv;
|
|
|
+ te[ 15 ] = ( n13 * t4 - n23 * t2 + n33 * t1 ) * detInv;
|
|
|
|
|
|
return this;
|
|
|
|
|
|
@@ -12481,7 +12489,9 @@ class Matrix4 {
|
|
|
position.y = te[ 13 ];
|
|
|
position.z = te[ 14 ];
|
|
|
|
|
|
- if ( this.determinant() === 0 ) {
|
|
|
+ const det = this.determinant();
|
|
|
+
|
|
|
+ if ( det === 0 ) {
|
|
|
|
|
|
scale.set( 1, 1, 1 );
|
|
|
quaternion.identity();
|
|
|
@@ -12494,8 +12504,7 @@ class Matrix4 {
|
|
|
const sy = _v1$5.set( te[ 4 ], te[ 5 ], te[ 6 ] ).length();
|
|
|
const sz = _v1$5.set( te[ 8 ], te[ 9 ], te[ 10 ] ).length();
|
|
|
|
|
|
- // if determine is negative, we need to invert one scale
|
|
|
- const det = this.determinant();
|
|
|
+ // if determinant is negative, we need to invert one scale
|
|
|
if ( det < 0 ) sx = - sx;
|
|
|
|
|
|
// scale the rotation part
|
|
|
@@ -13931,7 +13940,7 @@ class Object3D extends EventDispatcher {
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
- * Converts the given vector from this 3D object's word space to local space.
|
|
|
+ * Converts the given vector from this 3D object's world space to local space.
|
|
|
*
|
|
|
* @param {Vector3} vector - The vector to convert.
|
|
|
* @return {Vector3} The converted vector.
|
Mr.doob