x_ite 4.7.12 → 5.0.0

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

@@ -48,307 +48,307 @@
 
 
 define ([
-	"standard/Math/Algorithm",
+   "standard/Math/Algorithm",
 ],
 function (Algorithm)
 {
 "use strict";
 
-	function Vector3 (x, y, z)
-	{
-		this .x = x;
-		this .y = y;
-		this .z = z;
-	}
+   function Vector3 (x, y, z)
+   {
+      this .x = x;
+      this .y = y;
+      this .z = z;
+   }
 
-	Vector3 .prototype =
-	{
-		constructor: Vector3,
-		length: 3,
-		copy: function ()
-		{
-			const copy = Object .create (Vector3 .prototype);
-			copy .x = this .x;
-			copy .y = this .y;
-			copy .z = this .z;
-			return copy;
-		},
-		assign: function (vector)
-		{
-			this .x = vector .x;
-			this .y = vector .y;
-			this .z = vector .z;
-			return this;
-		},
-		set: function (x, y, z)
-		{
-			this .x = x;
-			this .y = y;
-			this .z = z;
-			return this;
-		},
-		equals: function (vector)
-		{
-			return this .x === vector .x &&
-			       this .y === vector .y &&
-			       this .z === vector .z;
-		},
-		negate: function ()
-		{
-			this .x = -this .x;
-			this .y = -this .y;
-			this .z = -this .z;
-			return this;
-		},
-		add: function (vector)
-		{
-			this .x += vector .x;
-			this .y += vector .y;
-			this .z += vector .z;
-			return this;
-		},
-		subtract: function (vector)
-		{
-			this .x -= vector .x;
-			this .y -= vector .y;
-			this .z -= vector .z;
-			return this;
-		},
-		multiply: function (value)
-		{
-			this .x *= value;
-			this .y *= value;
-			this .z *= value;
-			return this;
-		},
-		multVec: function (vector)
-		{
-			this .x *= vector .x;
-			this .y *= vector .y;
-			this .z *= vector .z;
-			return this;
-		},
-		divide: function (value)
-		{
-			this .x /= value;
-			this .y /= value;
-			this .z /= value;
-			return this;
-		},
-		divVec: function (vector)
-		{
-			this .x /= vector .x;
-			this .y /= vector .y;
-			this .z /= vector .z;
-			return this;
-		},
-		cross: function (vector)
-		{
-			const x = this .x, y = this .y, z = this .z;
+   Vector3 .prototype =
+   {
+      constructor: Vector3,
+      length: 3,
+      copy: function ()
+      {
+         const copy = Object .create (Vector3 .prototype);
+         copy .x = this .x;
+         copy .y = this .y;
+         copy .z = this .z;
+         return copy;
+      },
+      assign: function (vector)
+      {
+         this .x = vector .x;
+         this .y = vector .y;
+         this .z = vector .z;
+         return this;
+      },
+      set: function (x, y, z)
+      {
+         this .x = x;
+         this .y = y;
+         this .z = z;
+         return this;
+      },
+      equals: function (vector)
+      {
+         return this .x === vector .x &&
+                this .y === vector .y &&
+                this .z === vector .z;
+      },
+      negate: function ()
+      {
+         this .x = -this .x;
+         this .y = -this .y;
+         this .z = -this .z;
+         return this;
+      },
+      add: function (vector)
+      {
+         this .x += vector .x;
+         this .y += vector .y;
+         this .z += vector .z;
+         return this;
+      },
+      subtract: function (vector)
+      {
+         this .x -= vector .x;
+         this .y -= vector .y;
+         this .z -= vector .z;
+         return this;
+      },
+      multiply: function (value)
+      {
+         this .x *= value;
+         this .y *= value;
+         this .z *= value;
+         return this;
+      },
+      multVec: function (vector)
+      {
+         this .x *= vector .x;
+         this .y *= vector .y;
+         this .z *= vector .z;
+         return this;
+      },
+      divide: function (value)
+      {
+         this .x /= value;
+         this .y /= value;
+         this .z /= value;
+         return this;
+      },
+      divVec: function (vector)
+      {
+         this .x /= vector .x;
+         this .y /= vector .y;
+         this .z /= vector .z;
+         return this;
+      },
+      cross: function (vector)
+      {
+         const x = this .x, y = this .y, z = this .z;
 
-			this .x = y * vector .z - z * vector .y;
-			this .y = z * vector .x - x * vector .z;
-			this .z = x * vector .y - y * vector .x;
+         this .x = y * vector .z - z * vector .y;
+         this .y = z * vector .x - x * vector .z;
+         this .z = x * vector .y - y * vector .x;
 
-			return this;
-		},
-		normalize: function ()
-		{
-			let length = Math .hypot (this .x, this .y, this .z);
+         return this;
+      },
+      normalize: function ()
+      {
+         let length = Math .hypot (this .x, this .y, this .z);
 
-			if (length)
-			{
-				length = 1 / length;
+         if (length)
+         {
+            length = 1 / length;
 
-				this .x *= length;
-				this .y *= length;
-				this .z *= length;
-			}
+            this .x *= length;
+            this .y *= length;
+            this .z *= length;
+         }
 
-			return this;
-		},
-		dot: function (vector)
-		{
-			return this .x * vector .x +
-			       this .y * vector .y +
-			       this .z * vector .z;
-		},
-		norm: function ()
-		{
-			let
-				x = this .x,
-				y = this .y,
-				z = this .z;
+         return this;
+      },
+      dot: function (vector)
+      {
+         return this .x * vector .x +
+                this .y * vector .y +
+                this .z * vector .z;
+      },
+      norm: function ()
+      {
+         let
+            x = this .x,
+            y = this .y,
+            z = this .z;
 
-			return x * x +
-			       y * y +
-			       z * z;
-		},
-		abs: function ()
-		{
-			return Math .hypot (this .x, this .y, this .z);
-		},
-		distance: function (vector)
-		{
-			return Math .hypot (this .x - vector .x,
-			                    this .y - vector .y,
-			                    this .z - vector .z);
-		},
-		lerp: function (destination, t)
-		{
-			const
-				x = this .x,
-				y = this .y,
-				z = this .z;
+         return x * x +
+                y * y +
+                z * z;
+      },
+      abs: function ()
+      {
+         return Math .hypot (this .x, this .y, this .z);
+      },
+      distance: function (vector)
+      {
+         return Math .hypot (this .x - vector .x,
+                             this .y - vector .y,
+                             this .z - vector .z);
+      },
+      lerp: function (destination, t)
+      {
+         const
+            x = this .x,
+            y = this .y,
+            z = this .z;
 
-			this .x = x + t * (destination .x - x);
-			this .y = y + t * (destination .y - y);
-			this .z = z + t * (destination .z - z);
-			return this;
-		},
-		slerp: (function ()
-		{
-			const tmp = new Vector3 (0, 0, 0);
+         this .x = x + t * (destination .x - x);
+         this .y = y + t * (destination .y - y);
+         this .z = z + t * (destination .z - z);
+         return this;
+      },
+      slerp: (function ()
+      {
+         const tmp = new Vector3 (0, 0, 0);
 
-			return function (destination, t)
-			{
-				return Algorithm .simpleSlerp (this, tmp .assign (destination), t);
-			};
-		})(),
-		min: function (vector)
-		{
-			let
-				x = this .x,
-				y = this .y,
-				z = this .z;
+         return function (destination, t)
+         {
+            return Algorithm .simpleSlerp (this, tmp .assign (destination), t);
+         };
+      })(),
+      min: function (vector)
+      {
+         let
+            x = this .x,
+            y = this .y,
+            z = this .z;
 
-			for (const vector of arguments)
-			{
-				x = Math .min (x, vector .x);
-				y = Math .min (y, vector .y);
-				z = Math .min (z, vector .z);
-			}
+         for (const vector of arguments)
+         {
+            x = Math .min (x, vector .x);
+            y = Math .min (y, vector .y);
+            z = Math .min (z, vector .z);
+         }
 
-			this .x = x;
-			this .y = y;
-			this .z = z;
-			return this;
-		},
-		max: function (vector)
-		{
-			let
-				x = this .x,
-				y = this .y,
-				z = this .z;
+         this .x = x;
+         this .y = y;
+         this .z = z;
+         return this;
+      },
+      max: function (vector)
+      {
+         let
+            x = this .x,
+            y = this .y,
+            z = this .z;
 
-			for (const vector of arguments)
-			{
-				x = Math .max (x, vector .x);
-				y = Math .max (y, vector .y);
-				z = Math .max (z, vector .z);
-			}
+         for (const vector of arguments)
+         {
+            x = Math .max (x, vector .x);
+            y = Math .max (y, vector .y);
+            z = Math .max (z, vector .z);
+         }
 
-			this .x = x;
-			this .y = y;
-			this .z = z;
-			return this;
-		},
-		toString: function ()
-		{
-			return this .x + " " +
-			       this .y + " " +
-			       this .z;
-		}
-	};
+         this .x = x;
+         this .y = y;
+         this .z = z;
+         return this;
+      },
+      toString: function ()
+      {
+         return this .x + " " +
+                this .y + " " +
+                this .z;
+      }
+   };
 
-	Object .defineProperty (Vector3 .prototype, "0",
-	{
-		get: function () { return this .x; },
-		set: function (value) { this .x = value; },
-		enumerable: false,
-		configurable: false
-	});
+   Object .defineProperty (Vector3 .prototype, "0",
+   {
+      get: function () { return this .x; },
+      set: function (value) { this .x = value; },
+      enumerable: false,
+      configurable: false
+   });
 
-	Object .defineProperty (Vector3 .prototype, "1",
-	{
-		get: function () { return this .y; },
-		set: function (value) { this .y = value; },
-		enumerable: false,
-		configurable: false
-	});
+   Object .defineProperty (Vector3 .prototype, "1",
+   {
+      get: function () { return this .y; },
+      set: function (value) { this .y = value; },
+      enumerable: false,
+      configurable: false
+   });
 
-	Object .defineProperty (Vector3 .prototype, "2",
-	{
-		get: function () { return this .z; },
-		set: function (value) { this .z = value; },
-		enumerable: false,
-		configurable: false
-	});
+   Object .defineProperty (Vector3 .prototype, "2",
+   {
+      get: function () { return this .z; },
+      set: function (value) { this .z = value; },
+      enumerable: false,
+      configurable: false
+   });
 
-	Object .assign (Vector3,
-	{
-		Zero: new Vector3 (0, 0, 0),
-		One: new Vector3 (1, 1, 1),
-		xAxis: new Vector3 (1, 0, 0),
-		yAxis: new Vector3 (0, 1, 0),
-		zAxis: new Vector3 (0, 0, 1),
-		negate: function (vector)
-		{
-			return vector .copy () .negate ();
-		},
-		add: function (lhs, rhs)
-		{
-			return lhs .copy () .add (rhs);
-		},
-		subtract: function (lhs, rhs)
-		{
-			return lhs .copy () .subtract (rhs);
-		},
-		multiply: function (lhs, rhs)
-		{
-			return lhs .copy () .multiply (rhs);
-		},
-		multVec: function (lhs, rhs)
-		{
-			return lhs .copy () .multVec (rhs);
-		},
-		divide: function (lhs, rhs)
-		{
-			return lhs .copy () .divide (rhs);
-		},
-		divVec: function (lhs, rhs)
-		{
-			return lhs .copy () .divVec (rhs);
-		},
-		cross: function (lhs, rhs)
-		{
-			return lhs .copy () .cross (rhs);
-		},
-		normalize: function (vector)
-		{
-			return vector .copy () .normalize ();
-		},
-		dot: function (lhs, rhs)
-		{
-			return lhs .copy () .dot (rhs);
-		},
-		lerp: function (source, destination, t)
-		{
-			return source .copy () .lerp (destination, t);
-		},
-		slerp: function (source, destination, t)
-		{
-			return source .copy () .slerp (destination, t);
-		},
-		min: function (lhs, rhs)
-		{
-			return Vector3 .prototype .min .apply (lhs .copy (), arguments);
-		},
-		max: function (lhs, rhs)
-		{
-			return Vector3 .prototype .max .apply (lhs .copy (), arguments);
-		},
-	});
+   Object .assign (Vector3,
+   {
+      Zero: new Vector3 (0, 0, 0),
+      One: new Vector3 (1, 1, 1),
+      xAxis: new Vector3 (1, 0, 0),
+      yAxis: new Vector3 (0, 1, 0),
+      zAxis: new Vector3 (0, 0, 1),
+      negate: function (vector)
+      {
+         return vector .copy () .negate ();
+      },
+      add: function (lhs, rhs)
+      {
+         return lhs .copy () .add (rhs);
+      },
+      subtract: function (lhs, rhs)
+      {
+         return lhs .copy () .subtract (rhs);
+      },
+      multiply: function (lhs, rhs)
+      {
+         return lhs .copy () .multiply (rhs);
+      },
+      multVec: function (lhs, rhs)
+      {
+         return lhs .copy () .multVec (rhs);
+      },
+      divide: function (lhs, rhs)
+      {
+         return lhs .copy () .divide (rhs);
+      },
+      divVec: function (lhs, rhs)
+      {
+         return lhs .copy () .divVec (rhs);
+      },
+      cross: function (lhs, rhs)
+      {
+         return lhs .copy () .cross (rhs);
+      },
+      normalize: function (vector)
+      {
+         return vector .copy () .normalize ();
+      },
+      dot: function (lhs, rhs)
+      {
+         return lhs .copy () .dot (rhs);
+      },
+      lerp: function (source, destination, t)
+      {
+         return source .copy () .lerp (destination, t);
+      },
+      slerp: function (source, destination, t)
+      {
+         return source .copy () .slerp (destination, t);
+      },
+      min: function (lhs, rhs)
+      {
+         return Vector3 .prototype .min .apply (lhs .copy (), arguments);
+      },
+      max: function (lhs, rhs)
+      {
+         return Vector3 .prototype .max .apply (lhs .copy (), arguments);
+      },
+   });
 
-	return Vector3;
+   return Vector3;
 });