x_ite 4.2.17 → 4.7.7

package/src/standard/Math/Numbers/Quaternion.js

@@ -69,7 +69,7 @@ function (Vector3, Algorithm)
 		length: 4,
 		copy: function ()
 		{
-			var copy = Object .create (Quaternion .prototype);
+			const copy = Object .create (Quaternion .prototype);
 			copy .x = this .x;
 			copy .y = this .y;
 			copy .z = this .z;
@@ -94,7 +94,7 @@ function (Vector3, Algorithm)
 		},
 		setMatrix: function (matrix)
 		{
-			var i;
+			let i;
 
 			// First, find largest diagonal in matrix:
 			if (matrix [0] > matrix [4])
@@ -106,7 +106,7 @@ function (Vector3, Algorithm)
 				i = matrix [4] > matrix [8] ? 1 : 2;
 			}
 
-			var scalerow = matrix [0] + matrix [4] + matrix [8];
+			const scalerow = matrix [0] + matrix [4] + matrix [8];
 
 			if (scalerow > matrix [i * 3 + i])
 			{
@@ -114,7 +114,7 @@ function (Vector3, Algorithm)
 				this [3] = Math .sqrt (scalerow + 1) / 2;
 
 				// And compute other values:
-				var d = 4 * this [3];
+				const d = 4 * this [3];
 				this [0] = (matrix [5] - matrix [7]) / d;
 				this [1] = (matrix [6] - matrix [2]) / d;
 				this [2] = (matrix [1] - matrix [3]) / d;
@@ -122,14 +122,14 @@ function (Vector3, Algorithm)
 			else
 			{
 				// Compute x, y, or z first:
-				var j = (i + 1) % 3;
-				var k = (i + 2) % 3;
+				const j = (i + 1) % 3;
+				const k = (i + 2) % 3;
 
 				// Compute first value:
 				this [i] = Math .sqrt (matrix [i * 3 + i] - matrix [j * 3 + j] - matrix [k * 3 + k] + 1) / 2;
 
 				// And the others:
-				var d = 4 * this [i];
+				const d = 4 * this [i];
 				this [j] = (matrix [i * 3 + j] + matrix [j * 3 + i]) / d;
 				this [k] = (matrix [i * 3 + k] + matrix [k * 3 + i]) / d;
 				this [3] = (matrix [j * 3 + k] - matrix [k * 3 + j]) / d;
@@ -139,13 +139,13 @@ function (Vector3, Algorithm)
 		},
 		getMatrix: function (matrix)
 		{
-			var
+			const
 				x = this .x,
 				y = this .y,
 				z = this .z,
 				w = this .w;
 
-			var
+			const
 				a = x * x,
 				b = x * y,
 				c = y * y,
@@ -155,7 +155,7 @@ function (Vector3, Algorithm)
 				g = w * x,
 				h = w * y,
 				i = w * z;
-		
+
 			matrix [0] = 1 - 2 * (c + f);
 			matrix [1] =     2 * (b + i);
 			matrix [2] =     2 * (e - h);
@@ -226,7 +226,7 @@ function (Vector3, Algorithm)
 		},
 		multLeft: function (quat)
 		{
-			var
+			const
 				ax = this .x, ay = this .y, az = this .z, aw = this .w,
 				bx = quat .x, by = quat .y, bz = quat .z, bw = quat .w;
 
@@ -239,7 +239,7 @@ function (Vector3, Algorithm)
 		},
 		multRight: function (quat)
 		{
-			var
+			const
 				ax = this .x, ay = this .y, az = this .z, aw = this .w,
 				bx = quat .x, by = quat .y, bz = quat .z, bw = quat .w;
 
@@ -260,27 +260,27 @@ function (Vector3, Algorithm)
 		},
 		multVecQuat: function (vector)
 		{
-			var
+			const
 				qx = this .x, qy = this .y, qz = this .z, qw = this .w,
 				vx = vector .x, vy = vector .y, vz = vector .z,
-				a  = qw * qw - qx * qx - qy * qy - qz * qz,                   
-				b  = 2 * (vx * qx + vy * qy + vz * qz), 
-				c  = 2 * qw;                                       
+				a  = qw * qw - qx * qx - qy * qy - qz * qz,
+				b  = 2 * (vx * qx + vy * qy + vz * qz),
+				c  = 2 * qw;
 
 			vector .x = a * vx + b * qx + c * (qy * vz - qz * vy);
 			vector .y = a * vy + b * qy + c * (qz * vx - qx * vz);
 			vector .z = a * vz + b * qz + c * (qx * vy - qy * vx);
-			
+
 			return vector;
 		},
 		multQuatVec: function (vector)
 		{
-			var
+			const
 				qx = this .x, qy = this .y, qz = this .z, qw = this .w,
 				vx = vector .x, vy = vector .y, vz = vector .z,
-				a  = qw * qw - qx * qx - qy * qy - qz * qz,                    
-				b  = 2 * (vx * qx + vy * qy + vz * qz), 
-				c  = 2 * qw;                                       
+				a  = qw * qw - qx * qx - qy * qy - qz * qz,
+				b  = 2 * (vx * qx + vy * qy + vz * qz),
+				c  = 2 * qw;
 
 			vector .x = a * vx + b * qx - c * (qy * vz - qz * vy);
 			vector .y = a * vy + b * qy - c * (qz * vx - qx * vz);
@@ -290,11 +290,8 @@ function (Vector3, Algorithm)
 		},
 		normalize: function ()
 		{
-			var length = Math .sqrt (this .x * this .x +
-			                         this .y * this .y +
-			                         this .z * this .z +
-			                         this .w * this .w);
-			
+			let length = Math .hypot (this .x, this .y, this .z, this .w);
+
 			if (length)
 			{
 				length = 1 / length;
@@ -323,10 +320,7 @@ function (Vector3, Algorithm)
 		},
 		abs: function ()
 		{
-			return Math .sqrt (this .x * this .x +
-			                   this .y * this .y +
-			                   this .z * this .z +
-			                   this .w * this .w);
+			return Math .hypot (this .x, this .y, this .z, this .w);
 		},
 		pow: function (exponent)
 		{
@@ -336,7 +330,7 @@ function (Vector3, Algorithm)
 			if (this .isReal ())
 				return this .set (0, 0, 0, Math .pow (this .w, exponent));
 
-			var
+			const
 				l     = this .abs (),
 				theta = Math .acos (this .w / l),
 				li    = this .imag .abs (),
@@ -361,7 +355,7 @@ function (Vector3, Algorithm)
 					return this .set (Math .PI, 0, 0, Math .log (-this .w));
 			}
 
-			var
+			const
 				l = this .abs (),
 				v = this .imag .normalize () .multiply (Math .acos (this .w / l)),
 				w = Math .log (l);
@@ -373,11 +367,11 @@ function (Vector3, Algorithm)
 			return this;
 		},
 		exp: function ()
-		{	
+		{
 			if (this .isReal ())
 				return this .set (0, 0, 0, Math .exp (this .w));
 
-			var
+			const
 				i  = this .imag,
 				li = i .abs (),
 				ew = Math .exp (this .w),
@@ -390,9 +384,9 @@ function (Vector3, Algorithm)
 			this .w = w;
 			return this;
 		},
-		slerp: function (dest, t)
+		slerp: function (destination, t)
 		{
-			return Algorithm .slerp (this, t1 .assign (dest), t);
+			return Algorithm .slerp (this, t1 .assign (destination), t);
 		},
 		squad: function (a, b, destination, t)
 		{
@@ -454,7 +448,7 @@ function (Vector3, Algorithm)
 	{
 		get: (function ()
 		{
-			var result = new Vector3 (0, 0, 0);
+			const result = new Vector3 (0, 0, 0);
 
 			return function ()
 			{
@@ -469,137 +463,54 @@ function (Vector3, Algorithm)
 
 	Object .assign (Quaternion,
 	{
-		negate: function (vector)
+		negate: function (quat)
 		{
-			var copy = Object .create (this .prototype);
-			copy .x = -this .x;
-			copy .y = -this .y;
-			copy .z = -this .z;
-			copy .w = -this .w;
-			return copy;
+			return quat .copy () .negate ();
 		},
-		inverse: function (vector)
+		inverse: function (quat)
 		{
-			var copy = Object .create (this .prototype);
-			copy .x = -vector .x;
-			copy .y = -vector .y;
-			copy .z = -vector .z;
-			copy .w =  vector .w;
-			return copy;
+			return quat .copy () .inverse ();
 		},
 		add: function (lhs, rhs)
 		{
-			var copy = Object .create (this .prototype);
-			copy .x = lhs .x + rhs .x;
-			copy .y = lhs .y + rhs .y;
-			copy .z = lhs .z + rhs .z;
-			copy .w = lhs .w + rhs .w;
-			return copy;
+			return lhs .copy () .add (rhs);
 		},
 		subtract: function (lhs, rhs)
 		{
-			var copy = Object .create (this .prototype);
-			copy .x = lhs .x - rhs .x;
-			copy .y = lhs .y - rhs .y;
-			copy .z = lhs .z - rhs .z;
-			copy .w = lhs .w - rhs .w;
-			return copy;
+			return lhs .copy () .subtract (rhs);
 		},
 		multiply: function (lhs, rhs)
 		{
-			var copy = Object .create (this .prototype);
-			copy .x = lhs .x * rhs;
-			copy .y = lhs .y * rhs;
-			copy .z = lhs .z * rhs;
-			copy .w = lhs .w * rhs;
-			return copy;
+			return lhs .copy () .multiply (rhs);
 		},
 		multLeft: function (lhs, rhs)
 		{
-			var
-				copy = Object .create (this .prototype),
-				ax = lhs .x, ay = lhs .y, az = lhs .z, aw = lhs .w,
-				bx = rhs .x, by = rhs .y, bz = rhs .z, bw = rhs .w;
-
-			copy .x = aw * bx + ax * bw + ay * bz - az * by;
-			copy .y = aw * by + ay * bw + az * bx - ax * bz;
-			copy .z = aw * bz + az * bw + ax * by - ay * bx;
-			copy .w = aw * bw - ax * bx - ay * by - az * bz;
-
-			return copy;
+			return lhs .copy () .multLeft (rhs);
 		},
 		multRight: function (lhs, rhs)
 		{
-			var
-				copy = Object .create (this .prototype),
-				ax = lhs .x, ay = lhs .y, az = lhs .z, aw = lhs .w,
-				bx = rhs .x, by = rhs .y, bz = rhs .z, bw = rhs .w;
-
-			copy .x = bw * ax + bx * aw + by * az - bz * ay;
-			copy .y = bw * ay + by * aw + bz * ax - bx * az;
-			copy .z = bw * az + bz * aw + bx * ay - by * ax;
-			copy .w = bw * aw - bx * ax - by * ay - bz * az;
-
-			return copy;
+			return lhs .copy () .multRight (rhs);
 		},
 		divide: function (lhs, rhs)
 		{
-			var copy = Object .create (this .prototype);
-			copy .x = lhs .x / rhs;
-			copy .y = lhs .y / rhs;
-			copy .z = lhs .z / rhs;
-			copy .w = lhs .w / rhs;
-			return copy;
+			return lhs .copy () .divide (rhs);
 		},
 		normalize: function (quat)
 		{
-			var
-				copy   = Object .create (this .prototype),
-				x      = quat .x,
-				y      = quat .y,
-				z      = quat .z,
-				w      = quat .w,
-				length = Math .sqrt (x * x + y * y + z * z + w * w);
-
-			if (length)
-			{
-				length = 1 / length;
-
-				copy .x = x * length;
-				copy .y = y * length;
-				copy .z = z * length;
-				copy .w = w * length;
-			}
-			else
-			{
-				copy .x = 0;
-				copy .y = 0;
-				copy .z = 0;
-				copy .w = 0;
-			}
-
-			return copy;
+			return quat .copy () .normalize ();
 		},
-		slerp: function (source, dest, t)
+		slerp: function (source, destination, t)
 		{
-			return Algorithm .slerp (source .copy (), t2 .assign (dest), t);
+			return source .copy () .slerp (destination, t);
 		},
 		squad: function (source, a, b, destination, t)
 		{
-			// We must use shortest path slerp to prevent flipping.  Also see spline.
-
-			return Algorithm .slerp (Algorithm .slerp (source .copy (), t1 .assign (destination), t),
-                                  Algorithm .slerp (t2 .assign (a), t3 .assign (b), t),
-                                  2 * t * (1 - t));
+			return source .copy () .squad (a, b, destination, t);
 		},
 		/*
 		bezier: function (q0, a, b, q1, t)
 		{
-			var q11 = Algorithm .slerp (q0,  a, t);
-			var q12 = Algorithm .slerp ( a,  b, t);
-			var q13 = Algorithm .slerp ( b, q1, t);
-
-			return Algorithm .slerp (Algorithm .slerp (q11, q12, t), Algorithm .slerp (q12, q13, t), t);
+			return q0 .copy () .squad (a, b, q1, t);
 		},
 		*/
 		spline: function (Q0, Q1, Q2)
@@ -628,12 +539,12 @@ function (Vector3, Algorithm)
 		},
 	});
 
-	var
+	const
 		t1 = new Quaternion (0, 0, 0, 1),
 		t2 = new Quaternion (0, 0, 0, 1),
 		t3 = new Quaternion (0, 0, 0, 1);
-	
-	var
+
+	const
 		q0   = new Quaternion (0, 0, 0, 1),
 		q1   = new Quaternion (0, 0, 0, 1),
 		q2   = new Quaternion (0, 0, 0, 1),

package/src/standard/Math/Numbers/Rotation4.js

@@ -82,7 +82,7 @@ function (Quaternion,
 			}
 			case 2:
 			{
-				var
+				const
 					arg0 = arguments [0],
 					arg1 = arguments [1];
 
@@ -95,7 +95,7 @@ function (Quaternion,
 				           arg0 .y,
 				           arg0 .z,
 				           arg1);
-			
+
 			   return;
 			}
 			case 4:
@@ -113,7 +113,7 @@ function (Quaternion,
 		length: 4,
 		update: function ()
 		{
-			var rotation = this .get ();
+			const rotation = this .get ();
 
 			this .x_     = rotation .x;
 			this .y_     = rotation .y;
@@ -124,7 +124,7 @@ function (Quaternion,
 		},
 		copy: function ()
 		{
-			var copy = Object .create (Rotation4 .prototype);
+			const copy = Object .create (Rotation4 .prototype);
 
 			copy .x_     = this .x_;
 			copy .y_     = this .y_;
@@ -153,7 +153,7 @@ function (Quaternion,
 			this .z_     = z;
 			this .angle_ = angle;
 
-			var scale = Math .sqrt (x * x + y * y + z * z);
+			const scale = Math .hypot (x, y, z);
 
 			if (scale === 0)
 			{
@@ -163,31 +163,31 @@ function (Quaternion,
 
 			// Calculate quaternion
 
-			var
+			const
 				halfTheta = Algorithm .interval (angle / 2, 0, Math .PI),
-				scale     = Math .sin (halfTheta) / scale;
+				ascale    = Math .sin (halfTheta) / scale;
 
-			this .value .set (x * scale,
-			                  y * scale,
-			                  z * scale,
+			this .value .set (x * ascale,
+			                  y * ascale,
+			                  z * ascale,
 			                  Math .cos (halfTheta));
 			return this;
 		},
 		get: (function ()
 		{
-			var result = new Vector4 (0, 0, 0, 0);
+			const result = new Vector4 (0, 0, 0, 0);
 
 			return function ()
 			{
-				var value = this .value;
+				const value = this .value;
 
-				if (Math .abs (value .w > 1))
+				if (Math .abs (value .w) > 1)
 				{
 					return Vector4 .zAxis;
 				}
 				else
 				{
-					var
+					const
 						angle = Math .acos (value .w) * 2,
 						scale = Math .sin (angle / 2);
 
@@ -197,7 +197,7 @@ function (Quaternion,
 					}
 					else
 					{
-						var axis = value .imag .divide (scale);
+						const axis = value .imag .divide (scale);
 
 						return result .set (axis .x,
 						                    axis .y,
@@ -213,7 +213,7 @@ function (Quaternion,
 		},
 		setFromToVec: (function ()
 		{
-			var
+			const
 				from = new Vector3 (0, 0, 0),
 				to   = new Vector3 (0, 0, 0),
 				cv   = new Vector3 (0, 0, 0),
@@ -222,35 +222,35 @@ function (Quaternion,
 			return function (fromVec, toVec)
 			{
 				// https://bitbucket.org/Coin3D/coin/src/abc9f50968c9/src/base/SbRotation.cpp
-	
+
 				from .assign (fromVec) .normalize ();
 				to   .assign (toVec)   .normalize ();
-	
-				var
+
+				const
 					cos_angle = Algorithm .clamp (from .dot (to), -1, 1),
 					crossvec  = cv .assign (from) .cross (to) .normalize (),
 					crosslen  = crossvec .abs ();
-	
+
 				if (crosslen === 0)
 				{
 					// Parallel vectors
 					// Check if they are pointing in the same direction.
 					if (cos_angle > 0)
 						this .value .set (0, 0, 0, 1); // standard rotation
-	
+
 					// Ok, so they are parallel and pointing in the opposite direction
 					// of each other.
 					else
 					{
 						// Try crossing with x axis.
 						t .assign (from) .cross (Vector3 .xAxis);
-	
+
 						// If not ok, cross with y axis.
 						if (t .norm () === 0)
 							t .assign (from) .cross (Vector3 .yAxis);
-	
+
 						t .normalize ();
-	
+
 						this .value .set (t .x, t .y, t .z, 0);
 					}
 				}
@@ -260,15 +260,15 @@ function (Quaternion,
 					// The abs () wrapping is to avoid problems when `dot' "overflows" a tiny wee bit,
 					// which can lead to sqrt () returning NaN.
 					crossvec .multiply (Math .sqrt (Math .abs (1 - cos_angle) / 2));
-	
+
 					this .value .set (crossvec .x,
 					                  crossvec .y,
 					                  crossvec .z,
 					                  Math .sqrt (Math .abs (1 + cos_angle) / 2));
 				}
-	
+
 				this .update ();
-	
+
 				return this;
 			};
 		})(),
@@ -278,7 +278,7 @@ function (Quaternion,
 		},
 		getAxis: (function ()
 		{
-			var axis = new Vector3 (0, 0, 0);
+			const axis = new Vector3 (0, 0, 0);
 
 			return function ()
 			{
@@ -358,7 +358,7 @@ function (Quaternion,
 		}
 	};
 
-	var x = {
+	const x = {
 		get: function ()
 		{
 			return this .x_;
@@ -372,7 +372,7 @@ function (Quaternion,
 		configurable: false
 	};
 
-	var y = {
+	const y = {
 		get: function ()
 		{
 			return this .y_;
@@ -386,7 +386,7 @@ function (Quaternion,
 		configurable: false
 	};
 
-	var z = {
+	const z = {
 		get: function ()
 		{
 			return this .z_;
@@ -400,7 +400,7 @@ function (Quaternion,
 		configurable: false
 	};
 
-	var angle = {
+	const angle = {
 		get: function ()
 		{
 			return this .angle_;
@@ -434,49 +434,36 @@ function (Quaternion,
 		Identity: new Rotation4 (),
 		inverse: function (rotation)
 		{
-			var copy = Object .create (this .prototype);
-			copy .value = Quaternion .inverse (rotation .value);
-			copy .update ();
-			return copy;
+			return rotation .copy () .inverse ();
 		},
 		multRight: function (lhs, rhs)
 		{
-			var copy = Object .create (this .prototype);
-			copy .value = Quaternion .multRight (lhs .value, rhs .value);
-			copy .update ();
-			return copy;
+			return lhs .copy () .multRight (rhs);
 		},
-		normalize: function ()
+		normalize: function (rotation)
 		{
-			var copy = Object .create (this .prototype);
-			copy .value = rotation .value .copy ();
-			copy .update ();
-			return copy;
+			return rotation .copy () .normalize ();
 		},
 		slerp: function (source, destination, t)
 		{
-			var copy = Object .create (this .prototype);
-			copy .value = Quaternion .slerp (source .value, destination .value, t);
-			copy .update ();
-			return copy;
+			return source .copy () .slerp (destination, t);
 		},
 		squad: function (source, a, b, destination, t)
 		{
-			var copy = Object .create (this .prototype);
-			copy .value = Quaternion .squad (source .value, a, b, destination .value, t);
-			copy .update ();
-			return copy;
+			return source .copy () .squad (a, b, destination, t);
 		},
+		/*
 		bezier: function (source, a, b, destination, t)
 		{
-			var copy = Object .create (this .prototype);
+			const copy = Object .create (this .prototype);
 			copy .value = Quaternion .bezier (source .value, a, b, destination .value, t);
 			copy .update ();
 			return copy;
 		},
+		*/
 		spline: function (q0, q1, q2)
 		{
-			var copy = Object .create (this .prototype);
+			const copy = Object .create (this .prototype);
 			copy .value = Quaternion .spline (q0 .value, q1 .value, q2 .value);
 			copy .update ();
 			return copy;