x_ite 4.0.5 → 4.7.5

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

@@ -48,15 +48,14 @@
 
 
 define ([
-	"jquery",
 	"standard/Math/Algorithm",
 ],
-function ($, Algorithm)
+function (Algorithm)
 {
 "use strict";
 
 	function Vector4 (x, y, z, w)
-	{		
+	{
 		this .x = x;
 		this .y = y;
 		this .z = z;
@@ -69,7 +68,7 @@ function ($, Algorithm)
 		length: 4,
 		copy: function ()
 		{
-			var copy = Object .create (Vector4 .prototype);
+			const copy = Object .create (Vector4 .prototype);
 			copy .x = this .x;
 			copy .y = this .y;
 			copy .z = this .z;
@@ -99,6 +98,12 @@ function ($, Algorithm)
 			       this .z === vector .z &&
 			       this .w === vector .w;
 		},
+		getReal: function (vector)
+		{
+			vector .x = this .x / this .w;
+			vector .y = this .y / this .w;
+			vector .z = this .z / this .w;
+		},
 		negate: function ()
 		{
 			this .x = -this .x;
@@ -157,11 +162,8 @@ function ($, 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;
@@ -183,65 +185,84 @@ function ($, Algorithm)
 		},
 		norm: function ()
 		{
-			return this .x * this .x +
-			       this .y * this .y +
-			       this .z * this .z +
-			       this .w * this .w;
+			const
+				x = this .x,
+				y = this .y,
+				z = this .z,
+				w = this .w;
+
+			return x * x +
+			       y * y +
+			       z * z +
+			       w * w;
 		},
 		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);
 		},
 		distance: function (vector)
 		{
-			var
-				x = this .x - vector .x,
-				y = this .y - vector .y,
-				z = this .z - vector .z,
-				w = this .w - vector .w;
-
-			return Math .sqrt (x * x +
-			                   y * y +
-			                   z * z +
-			                   w * w);
+			return Math .hypot (this .x - vector .x,
+			                    this .y - vector .y,
+			                    this .z - vector .z,
+			                    this .w - vector .w);
 		},
-		lerp: function (dest, t)
+		lerp: function (destination, t)
 		{
-			this .x = this .x + t * (dest .x - this .x);
-			this .y = this .y + t * (dest .y - this .y);
-			this .z = this .z + t * (dest .z - this .z);
-			this .w = this .w + t * (dest .w - this .w);
+			const
+				x = this .x,
+				y = this .y,
+				z = this .z,
+				w = this .w;
+
+			this .x = x + t * (destination .x - x);
+			this .y = y + t * (destination .y - y);
+			this .z = z + t * (destination .z - z);
+			this .w = w + t * (destination .w - w);
 			return this;
 		},
 		min: function (vector)
 		{
-			for (var i = 0, length = arguments .length; i < length; ++ i)
-			{
-				var vector = arguments [i];
+			let
+				x = this .x,
+				y = this .y,
+				z = this .z,
+				w = this .w;
 
-				this .x = Math .min (this .x, vector .x);
-				this .y = Math .min (this .y, vector .y);
-				this .z = Math .min (this .z, vector .z);
-				this .w = Math .min (this .w, vector .w);
+			for (const vector of arguments)
+			{
+				x = Math .min (x, vector .x);
+				y = Math .min (y, vector .y);
+				z = Math .min (z, vector .z);
+				w = Math .min (w, vector .w);
 			}
 
+			this .x = x;
+			this .y = y;
+			this .z = z;
+			this .w = w;
 			return this;
 		},
 		max: function (vector)
 		{
-			for (var i = 0, length = arguments .length; i < length; ++ i)
-			{
-				var vector = arguments [i];
+			let
+				x = this .x,
+				y = this .y,
+				z = this .z,
+				w = this .w;
 
-				this .x = Math .max (this .x, vector .x);
-				this .y = Math .max (this .y, vector .y);
-				this .z = Math .max (this .z, vector .z);
-				this .w = Math .max (this .w, vector .w);
+			for (const vector of arguments)
+			{
+				x = Math .max (x, vector .x);
+				y = Math .max (y, vector .y);
+				z = Math .max (z, vector .z);
+				w = Math .max (w, vector .w);
 			}
 
+			this .x = x;
+			this .y = y;
+			this .z = z;
+			this .w = w;
 			return this;
 		},
 		toString: function ()
@@ -285,152 +306,61 @@ function ($, Algorithm)
 		configurable: false
 	});
 
-	$.extend (Vector4,
+	Object .assign (Vector4,
 	{
 		Zero: new Vector4 (0, 0, 0, 0),
 		One: new Vector4 (1, 1, 1, 1),
+		xAxis: new Vector4 (1, 0, 0, 0),
+		yAxis: new Vector4 (0, 1, 0, 0),
+		zAxis: new Vector4 (0, 0, 1, 0),
+		wAxis: new Vector4 (0, 0, 0, 1),
 		negate: function (vector)
 		{
-			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 vector .copy () .negate ();
 		},
 		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);
 		},
 		multVec: 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 () .multVec (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);
 		},
 		divVec: 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 () .divVec (rhs);
 		},
 		normalize: function (vector)
 		{
-			var
-				copy   = Object .create (this .prototype),
-				x      = vector .x,
-				y      = vector .y,
-				z      = vector .z,
-				w      = vector .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 vector .copy () .normalize ();
 		},
 		dot: function (lhs, rhs)
 		{
-			return lhs .dot (rhs);
+			return lhs .copy () .dot (rhs);
 		},
-		lerp: function (source, dest, t)
+		lerp: function (source, destination, t)
 		{
-			return new Vector4 (Algorithm .lerp (source .x, dest .x, t),
-			                    Algorithm .lerp (source .y, dest .y, t),
-			                    Algorithm .lerp (source .z, dest .z, t),
-			                    Algorithm .lerp (source .w, dest .w, t));
+			return source .copy () .lerp (destination, t);
 		},
 		min: function (lhs, rhs)
 		{
-			var
-				x = lhs .x,
-				y = lhs .y,
-				z = lhs .z,
-				w = lhs .w;
-
-			for (var i = 1, length = arguments .length; i < length; ++ i)
-			{
-				var vector = arguments [i];
-
-				x = Math .min (x, vector .x);
-				y = Math .min (y, vector .y);
-				z = Math .min (z, vector .z);
-				w = Math .min (w, vector .w);
-			}
-
-			return new Vector4 (x, y, z, w);
+			return Vector4 .prototype .min .apply (lhs .copy (), arguments);
 		},
 		max: function (lhs, rhs)
 		{
-			var
-				x = lhs .x,
-				y = lhs .y,
-				z = lhs .z,
-				w = lhs .w;
-
-			for (var i = 1, length = arguments .length; i < length; ++ i)
-			{
-				var vector = arguments [i];
-
-				x = Math .max (x, vector .x);
-				y = Math .max (y, vector .y);
-				z = Math .max (z, vector .z);
-				w = Math .max (w, vector .w);
-			}
-
-			return new Vector4 (x, y, z, w);
+			return Vector4 .prototype .max .apply (lhs .copy (), arguments);
 		},
 	});
 

package/src/standard/Math/Utility/BVH.js

@@ -58,14 +58,14 @@ function (Vector3,
 {
 "use strict";
 
-	var
+	const
 		v0  = new Vector3 (0, 0, 0),
 		v1  = new Vector3 (0, 0, 0),
 		v2  = new Vector3 (0, 0, 0),
 		uvt = { u: 0, v: 0, t: 0 };
 
 	// Box normals for bbox / line intersection.
-	var boxNormals = [
+	const boxNormals = [
 		new Vector3 (0,  0,  1), // front
 		new Vector3 (0,  0, -1), // back
 		new Vector3 (0,  1,  0), // top
@@ -78,7 +78,7 @@ function (Vector3,
 	{
 		function compare (a, b)
 		{
-			var
+			const
 				vertices = compare .vertices;
 				axis     = compare .axis;
 
@@ -104,13 +104,13 @@ function (Vector3,
 	{
 		intersectsLine: function (line, intersections, intersectionNormals)
 		{
-			var
+			const
 				vertices = this .vertices,
 				normals  = this .normals,
 				i4       = this .i4,
 				i3       = this .i3;
 
-			v0 .x = vertices [i4 + 0]; v0 .y = vertices [i4 + 1]; v0 .z = vertices [i4 +  2];
+			v0 .x = vertices [i4];     v0 .y = vertices [i4 + 1]; v0 .z = vertices [i4 +  2];
 			v1 .x = vertices [i4 + 4]; v1 .y = vertices [i4 + 5]; v1 .z = vertices [i4 +  6];
 			v2 .x = vertices [i4 + 8]; v2 .y = vertices [i4 + 9]; v2 .z = vertices [i4 + 10];
 
@@ -118,29 +118,31 @@ function (Vector3,
 			{
 				// Get barycentric coordinates.
 
-				var
+				const
 					u = uvt .u,
 					v = uvt .v,
 					t = 1 - u - v;
 
 				// Determine vectors for X3DPointingDeviceSensors.
 
-				var i = intersections .size ++;
+				const i = intersections .size ++;
 
 				if (i >= intersections .length)
-				{
-					intersections       .push (new Vector3 (0, 0, 0));
-					intersectionNormals .push (new Vector3 (0, 0, 0));
-				}
+					intersections .push (new Vector3 (0, 0, 0));
 
-				intersections [i] .set (t * vertices [i4 + 0] + u * vertices [i4 + 4] + v * vertices [i4 +  8],
+				intersections [i] .set (t * vertices [i4]     + u * vertices [i4 + 4] + v * vertices [i4 +  8],
 				                        t * vertices [i4 + 1] + u * vertices [i4 + 5] + v * vertices [i4 +  9],
 				                        t * vertices [i4 + 2] + u * vertices [i4 + 6] + v * vertices [i4 + 10]);
 
+				if (intersectionNormals)
+				{
+					if (i >= intersectionNormals .length)
+						intersectionNormals .push (new Vector3 (0, 0, 0));
 
-				intersectionNormals [i] .set (t * normals [i3 + 0] + u * normals [i3 + 3] + v * normals [i3 + 6],
-				                              t * normals [i3 + 1] + u * normals [i3 + 4] + v * normals [i3 + 7],
-				                              t * normals [i3 + 2] + u * normals [i3 + 5] + v * normals [i3 + 8]);
+					intersectionNormals [i] .set (t * normals [i3]     + u * normals [i3 + 3] + v * normals [i3 + 6],
+					                              t * normals [i3 + 1] + u * normals [i3 + 4] + v * normals [i3 + 7],
+					                              t * normals [i3 + 2] + u * normals [i3 + 5] + v * normals [i3 + 8]);
+				}
 			}
 		},
 	};
@@ -152,23 +154,24 @@ function (Vector3,
 		this .planes       = [ ];
 		this .intersection = new Vector3 (0, 0, 0);
 
-		var
+		const
 			vertices = tree .vertices,
 			min      = this .min,
 			max      = this .max,
-			last     = first + size,
-			t        = triangles [first] * 12;
+			last     = first + size;
+
+		let t = triangles [first] * 12;
 
 		// Calculate bbox
 
 		min .set (vertices [t], vertices [t + 1], vertices [t + 2]);
 		max .assign (min);
 
-		for (var i = first; i < last; ++ i)
+		for (let i = first; i < last; ++ i)
 		{
 			t = triangles [i] * 12;
 
-			v0 .set (vertices [t + 0], vertices [t + 1], vertices [t + 2]);
+			v0 .set (vertices [t],     vertices [t + 1], vertices [t + 2]);
 			v1 .set (vertices [t + 4], vertices [t + 5], vertices [t + 6]);
 			v2 .set (vertices [t + 8], vertices [t + 9], vertices [t + 10]);
 
@@ -176,7 +179,7 @@ function (Vector3,
 			max .max (v0, v1, v2);
 		}
 
-		for (var i = 0; i < 5; ++ i)
+		for (let i = 0; i < 5; ++ i)
 			this .planes [i] = new Plane3 (i % 2 ? min : max, boxNormals [i]);
 
 		// Sort and split array
@@ -197,7 +200,7 @@ function (Vector3,
 
 		// Split array
 
-		var rightSize = size - leftSize;
+		const rightSize = size - leftSize;
 
 		// Construct left and right node
 
@@ -224,7 +227,7 @@ function (Vector3,
 		},
 		intersectsBBox: function (line)
 		{
-			var
+			const
 				planes       = this .planes,
 				min          = this .min,
 				max          = this .max,
@@ -280,11 +283,11 @@ function (Vector3,
 		},
 		getLongestAxis: function (min, max)
 		{
-			var
+			const
 				x = max .x - min .x,
 				y = max .y - min .y,
 				z = max .z - min .z;
-	
+
 			if (x < y)
 			{
 				if (y < z)
@@ -307,13 +310,15 @@ function (Vector3,
 		this .vertices = vertices;
 		this .normals  = normals;
 
-		var numTriangles = vertices .length / 12;
-	
+		const numTriangles = vertices .length / 12;
+
 		switch (numTriangles)
 		{
 			case 0:
+			{
 				this .root = null;
 				break;
+			}
 			case 1:
 			{
 				this .root = new Triangle (this, 0);
@@ -321,9 +326,9 @@ function (Vector3,
 			}
 			default:
 			{
-				var triangles = [ ];
+				const triangles = [ ];
 
-				for (var i = 0; i < numTriangles; ++ i)
+				for (let i = 0; i < numTriangles; ++ i)
 					triangles .push (i);
 
 				this .sorter = new QuickSort (triangles, SortComparator (vertices, 0));
@@ -337,7 +342,7 @@ function (Vector3,
 	BVH .prototype =
 	{
 		constructor: BVH,
-		
+
 		intersectsLine: function (line, intersections, intersectionNormals)
 		{
 			intersections .size = 0;

package/src/standard/Math/Utility/MatrixStack.js

@@ -47,30 +47,27 @@
  ******************************************************************************/
 
 
-define ([
-	"jquery",
-],
-function ($)
+define (function ()
 {
 "use strict";
 
 	function MatrixStack (Type)
 	{
-		return $.extend ([ new Type () ],
+		return Object .assign ([ new Type () ],
 		{
 			top: 0,
 			set: function (matrix)
 			{
 				this [this .top] .assign (matrix);
 			},
-			get: function (matrix)
+			get: function ()
 			{
 				return this [this .top];
 			},
 			push: function ()
 			{
-				var top = ++ this .top;
-			
+				const top = ++ this .top;
+
 				if (top < this .length)
 					this [top] .assign (this [top - 1]);
 				else
@@ -78,7 +75,7 @@ function ($)
 			},
 			pushMatrix: function (matrix)
 			{
-				var top = ++ this .top;
+				const top = ++ this .top;
 
 				if (top < this .length)
 					this [top] .assign (matrix);

package/src/standard/Networking/BinaryTransport.js

@@ -63,14 +63,14 @@ define (function ()
 					send: function (headers, callback)
 					{
 						// Setup all variables
-						var xhr = options .xhr ();
+						const xhr = options .xhr ();
 
 						xhr .open (options .type, options .url, options .async, options .username, options .password);
 
 						// Apply custom fields if provided
-						if ( options.xhrFields )
+						if (options .xhrFields)
 						{
-							for (var i in options.xhrFields)
+							for (const i in options .xhrFields)
 								xhr [i] = options .xhrFields [i];
 						}
 
@@ -79,7 +79,7 @@ define (function ()
 							xhr .overrideMimeType (options .mimeType);
 
 						// Setup custom headers
-						for (var i in headers)
+						for (const i in headers)
 							xhr .setRequestHeader (i, headers [i]);
 
 						// Setup onload callback
@@ -87,7 +87,7 @@ define (function ()
 						{
 							xhr .onload = xhr .onerror = null;
 
-							var data = { };
+							const data = { };
 
 							data [options .dataType] = xhr .response;
 
@@ -101,14 +101,14 @@ define (function ()
 
 							callback (xhr .status || 404, xhr .statusText);
 						};
-						
+
 						// Send data
 						xhr .responseType = options .responseType || "blob";
 						xhr .send (options .hasContent && options .data || null);
 					},
 					abort: function ()
 					{
-						var xhr = options .xhr ();
+						const xhr = options .xhr ();
 
 						xhr .onload = xhr .onerror = null;
 
@@ -118,4 +118,4 @@ define (function ()
 			}
 		});
 	};
-});
+});