update to three.js r70.

threejs/tests/math/test_unit_math.ts

@@ -779,6 +779,20 @@
         return true;
     };
 
+    var eulerEquals = function (a, b, tolerance?: any) {
+        tolerance = tolerance || 0.0001;
+        var diff = Math.abs(a.x - b.x) + Math.abs(a.y - b.y) + Math.abs(a.z - b.z);
+        return (diff < tolerance);
+    };
+
+
+    var quatEquals = function (a, b, tolerance?: any) {
+        tolerance = tolerance || 0.0001;
+        var diff = Math.abs(a.x - b.x) + Math.abs(a.y - b.y) + Math.abs(a.z - b.z) + Math.abs(a.w - b.w);
+        return (diff < tolerance);
+    };
+
+
     test( "constructor/equals", function() {
         var a = new THREE.Euler();
         ok( a.equals( eulerZero ), "Passed!" );
@@ -799,13 +813,23 @@
 
     });
 
-    test( "set", function() {
+    test("set/setFromVector3/toVector3", function () {
         var a = new THREE.Euler();
 
         a.set( 0, 1, 0, "ZYX" );
         ok( a.equals( eulerAzyx ), "Passed!" );
         ok( ! a.equals( eulerAxyz ), "Passed!" );
-        ok( ! a.equals( eulerZero ), "Passed!" );
+        ok(!a.equals(eulerZero), "Passed!");
+
+        var vec = new THREE.Vector3(0, 1, 0);
+
+        var b = new THREE.Euler().setFromVector3(vec, "ZYX");
+        console.log(a, b);
+        ok(a.equals(b), "Passed!");
+
+        var c = b.toVector3();
+        console.log(c, vec);
+        ok(c.equals(vec), "Passed!");
     });
 
     test( "Quaternion.setFromEuler/Euler.fromQuaternion", function() {
@@ -816,7 +840,7 @@
 
             var v2 = new THREE.Euler().setFromQuaternion( q, v.order );
             var q2 = new THREE.Quaternion().setFromEuler( v2 );
-            ok( q.equals( q2 ), "Passed!" );
+            ok(eulerEquals(q, q2), "Passed!");
         }
     });
 
@@ -841,14 +865,33 @@
 
             v.reorder( 'YZX' );
             var q2 = new THREE.Quaternion().setFromEuler( v );
-            ok( q.equals( q2 ), "Passed!" );
+            ok(quatEquals(q, q2), "Passed!");	
 
             v.reorder( 'ZXY' );
             var q3 = new THREE.Quaternion().setFromEuler( v );
-            ok( q.equals( q3 ), "Passed!" );
+            ok(quatEquals(q, q3), "Passed!");
         }
     });
 
+    test("gimbalLocalQuat", function () {
+        // known problematic quaternions
+        var q1 = new THREE.Quaternion(0.5207769385244341, -0.4783214164122354, 0.520776938524434, 0.47832141641223547);
+        var q2 = new THREE.Quaternion(0.11284905712620674, 0.6980437630368944, -0.11284905712620674, 0.6980437630368944);
+
+        var eulerOrder = "ZYX";
+
+        // create Euler directly from a Quaternion
+        var eViaQ1 = new THREE.Euler().setFromQuaternion(q1, eulerOrder); // there is likely a bug here
+
+        // create Euler from Quaternion via an intermediate Matrix4
+        var mViaQ1 = new THREE.Matrix4().makeRotationFromQuaternion(q1);
+        var eViaMViaQ1 = new THREE.Euler().setFromRotationMatrix(mViaQ1, eulerOrder);
+
+        // the results here are different
+        ok(eulerEquals(eViaQ1, eViaMViaQ1), "Passed!");  // this result is correct
+
+    });
+
     // -------------------------------------------- Frustum
 
     var unit3 = new THREE.Vector3( 1, 0, 0 );
@@ -1483,6 +1526,36 @@
         }
     });
 
+    test("makeBasis/extractBasis", function () {
+        var identityBasis = [new THREE.Vector3(1, 0, 0), new THREE.Vector3(0, 1, 0), new THREE.Vector3(0, 0, 1)];
+        var a = new THREE.Matrix4().makeBasis(identityBasis[0], identityBasis[1], identityBasis[2]);
+        var identity = new THREE.Matrix4();
+        ok(matrixEquals4(a, identity), "Passed!");
+
+        var testBases = [[new THREE.Vector3(0, 1, 0), new THREE.Vector3(-1, 0, 0), new THREE.Vector3(0, 0, 1)]];
+    	for (var i = 0; i < testBases.length; i++) {
+            var testBasis = testBases[i];
+            var b = new THREE.Matrix4().makeBasis(testBasis[0], testBasis[1], testBasis[2]);
+            var outBasis = [new THREE.Vector3(), new THREE.Vector3(), new THREE.Vector3()];
+            b.extractBasis(outBasis[0], outBasis[1], outBasis[2]);
+            // check what goes in, is what comes out.
+            for (var j = 0; j < outBasis.length; j++) {
+                console.log(outBasis[j], testBasis[j]);
+                ok(outBasis[j].equals(testBasis[j]), "Passed!");
+            }
+
+            // get the basis out the hard war
+            for (var j = 0; j < identityBasis.length; j++) {
+                outBasis[j].copy(identityBasis[j]);
+                outBasis[j].applyMatrix4(b);
+            }
+            // did the multiply method of basis extraction work?
+            for (var j = 0; j < outBasis.length; j++) {
+                ok(outBasis[j].equals(testBasis[j]), "Passed!");
+            }
+        }
+    });
+
     test( "transpose", function() {
         var a = new THREE.Matrix4();
         var b = a.clone().transpose();