x_ite 4.2.17 → 4.7.7

package/src/standard/Math/Geometry/Triangle2.js

@@ -56,26 +56,26 @@ define (function ()
 		{
 		   // https://en.wikipedia.org/wiki/Barycentric_coordinate_system
 
-		   var det = (b.y - c.y) * (a.x - c.x) + (c.x - b.x) * (a.y - c.y);
+		   const det = (b.y - c.y) * (a.x - c.x) + (c.x - b.x) * (a.y - c.y);
 
 			if (det == 0)
 				return false;
 
-		   var u = ((b.y - c.y) * (point .x - c.x) + (c.x - b.x) * (point .y - c.y)) / det;
+			const u = ((b.y - c.y) * (point .x - c.x) + (c.x - b.x) * (point .y - c.y)) / det;
 
 		   if (u < 0 || u > 1)
 		      return false;
 
-		   var v = ((c.y - a.y) * (point .x - c.x) + (a.x - c.x) * (point .y - c.y)) / det;
+			const v = ((c.y - a.y) * (point .x - c.x) + (a.x - c.x) * (point .y - c.y)) / det;
 
 		   if (v < 0 || v > 1)
 		      return false;
 
-		   var t = 1 - u - v;
+			const t = 1 - u - v;
 
 		   if (t < 0 || t > 1)
 		      return false;
-		   
+
 			return true;
 		},
 	};

package/src/standard/Math/Geometry/Triangle3.js

@@ -60,7 +60,7 @@ function (Vector3,
 	return {
 	   area: (function ()
 		{
-			var
+			const
 				B = new Vector3 (0, 0, 0),
 				C = new Vector3 (0, 0, 0);
 
@@ -71,7 +71,7 @@ function (Vector3,
 		})(),
 		normal: function (v1, v2, v3, normal)
 		{
-			var
+			const
 				x1 = v3 .x - v2 .x,
 				y1 = v3 .y - v2 .y,
 				z1 = v3 .z - v2 .z,
@@ -87,7 +87,7 @@ function (Vector3,
 		},
 		quadNormal: function (v1, v2, v3, v4, normal)
 		{
-			var
+			const
 				x1 = v3 .x - v1 .x,
 				y1 = v3 .y - v1 .y,
 				z1 = v3 .z - v1 .z,
@@ -103,7 +103,7 @@ function (Vector3,
 		},
 		triangulatePolygon: (function ()
 		{
-			var tessy = (function ()
+			const tessy = (function ()
 			{
 				// Function called for each vertex of tesselator output.
 				function vertexCallback (data, polyVertArray)
@@ -123,7 +123,7 @@ function (Vector3,
 					console .log ('error callback');
 					console .log ('error number: ' + errno);
 				}
-		
+
 				// Callback for when segments intersect and must be split.
 				function combineCallback (coords, data, weight)
 				{
@@ -137,7 +137,7 @@ function (Vector3,
 					// console .log ('edge flag: ' + flag);
 				}
 
-				var tessy = new libtess .GluTesselator ();
+				const tessy = new libtess .GluTesselator ();
 
 				tessy .gluTessCallback (libtess .gluEnum .GLU_TESS_VERTEX_DATA,  vertexCallback);
 				tessy .gluTessCallback (libtess .gluEnum .GLU_TESS_BEGIN,        beginCallback);
@@ -152,19 +152,17 @@ function (Vector3,
 
 			return function (/* contour, [ contour, ..., ] triangles */)
 			{
-				var triangles = arguments [arguments .length - 1];
+				const triangles = arguments [arguments .length - 1];
 
 				tessy .gluTessBeginPolygon (triangles);
 
-				for (var i = 0, length = arguments .length - 1; i < length; ++ i)
+				for (let i = 0, length = arguments .length - 1; i < length; ++ i)
 				{
 					tessy .gluTessBeginContour ();
 
-					var contour = arguments [i];
-
-					for (var j = 0; j < contour .length; ++ j)
+					for (const contour of arguments [i])
 					{
-						tessy .gluTessVertex (contour [j], contour [j]);
+						tessy .gluTessVertex (contour, contour);
 					}
 
 					tessy .gluTessEndContour ();
@@ -178,7 +176,7 @@ function (Vector3,
 		triangulateConvexPolygon: function (vertices, triangles)
 		{
 			// Fallback: Very simple triangulation for convex polygons.
-			for (var i = 1, length = vertices .length - 1; i < length; ++ i)
+			for (let i = 1, length = vertices .length - 1; i < length; ++ i)
 				triangles .push (vertices [0], vertices [i], vertices [i + 1]);
 		},
 		getPolygonNormal: function (vertices, normal)
@@ -190,7 +188,7 @@ function (Vector3,
 
 			var next = vertices [0];
 
-			for (var i = 0, length = vertices .length; i < length; ++ i)
+			for (let i = 0, length = vertices .length; i < length; ++ i)
 			{
 				var
 					current = next,

package/src/standard/Math/Geometry/ViewVolume.js

@@ -48,87 +48,158 @@
 
 
 define ([
-	"standard/Math/Geometry/Line3",
 	"standard/Math/Geometry/Plane3",
 	"standard/Math/Geometry/Triangle3",
 	"standard/Math/Numbers/Vector3",
 	"standard/Math/Numbers/Vector4",
 	"standard/Math/Numbers/Matrix4",
+	"standard/Math/Algorithms/SAT",
 ],
-function (Line3, Plane3, Triangle3, Vector3, Vector4, Matrix4)
+function (Plane3,
+          Triangle3,
+          Vector3,
+          Vector4,
+          Matrix4,
+          SAT)
 {
 "use strict";
 
-	var
-		p1     = new Vector3 (0, 0, 0),
-		p2     = new Vector3 (0, 0, 0),
-		p3     = new Vector3 (0, 0, 0),
-		p4     = new Vector3 (0, 0, 0),
-		p5     = new Vector3 (0, 0, 0),
-		p6     = new Vector3 (0, 0, 0),
-		near   = new Vector3 (0, 0, 0),
-		far    = new Vector3 (0, 0, 0),
-		matrix = new Matrix4 (),
-		normal = new Vector3 (0, 0, 0),
-		vin    = new Vector4 (0, 0, 0, 0);
-
-	function ViewVolume ()
+	/*
+	 * p7 -------- p6  far plane
+	 * | \         | \
+	 * | p3 --------- p2
+	 * |  |        |  |
+	 * |  |        |  |
+	 * p4 |______ p5  |
+	 *  \ |         \ |
+	 *   \|          \|
+	 *    p0 -------- p1  near plane
+	 */
+
+	function ViewVolume (projectionMatrix, viewport, scissor)
 	{
 		this .viewport = new Vector4 (0, 0, 0, 0);
 		this .scissor  = new Vector4 (0, 0, 0, 0);
-		
+
+		this .points = [
+			new Vector3 (0, 0, 0),
+			new Vector3 (0, 0, 0),
+			new Vector3 (0, 0, 0),
+			new Vector3 (0, 0, 0),
+
+			new Vector3 (0, 0, 0),
+			new Vector3 (0, 0, 0),
+			new Vector3 (0, 0, 0),
+			new Vector3 (0, 0, 0),
+		];
+
+		this .normals = [
+			new Vector3 (0, 0, 0), // front
+			new Vector3 (0, 0, 0), // left
+			new Vector3 (0, 0, 0), // right
+			new Vector3 (0, 0, 0), // top
+			new Vector3 (0, 0, 0), // bottom
+			new Vector3 (0, 0, 0), // back
+		];
+
+		this .edges = [
+			new Vector3 (0, 0, 0),
+			new Vector3 (0, 0, 0),
+			new Vector3 (0, 0, 0),
+			new Vector3 (0, 0, 0),
+
+			new Vector3 (0, 0, 0),
+			new Vector3 (0, 0, 0),
+			new Vector3 (0, 0, 0),
+			new Vector3 (0, 0, 0),
+		];
+
 		this .planes = [
-			new Plane3 (Vector3 .Zero, Vector3 .Zero),  // front
-			new Plane3 (Vector3 .Zero, Vector3 .Zero),  // left
-			new Plane3 (Vector3 .Zero, Vector3 .Zero),  // right
-			new Plane3 (Vector3 .Zero, Vector3 .Zero),  // top
-			new Plane3 (Vector3 .Zero, Vector3 .Zero),  // bottom
-			new Plane3 (Vector3 .Zero, Vector3 .Zero),  // back
+			new Plane3 (Vector3 .Zero, Vector3 .Zero), // front
+			new Plane3 (Vector3 .Zero, Vector3 .Zero), // left
+			new Plane3 (Vector3 .Zero, Vector3 .Zero), // right
+			new Plane3 (Vector3 .Zero, Vector3 .Zero), // top
+			new Plane3 (Vector3 .Zero, Vector3 .Zero), // bottom
+			new Plane3 (Vector3 .Zero, Vector3 .Zero), // back
 		];
+
+		if (arguments .length)
+			this .set (projectionMatrix, viewport, scissor);
 	}
 
 	ViewVolume .prototype =
 	{
 		constructor: ViewVolume,
-		set: function (projectionMatrix, viewport, scissor)
+		set: (function ()
 		{
-			try
-			{
-				this .viewport .assign (viewport);
-				this .scissor  .assign (scissor);
-
-				var
-					x1 = scissor [0],
-					x2 = scissor [0] + scissor [2],
-					y1 = scissor [1],
-					y2 = scissor [1] + scissor [3];
-
-				matrix .assign (projectionMatrix) .inverse ();
-
-				ViewVolume .unProjectPointMatrix (x1, y2, 1, matrix, viewport, p1),
-				ViewVolume .unProjectPointMatrix (x1, y1, 1, matrix, viewport, p2),
-				ViewVolume .unProjectPointMatrix (x1, y1, 0, matrix, viewport, p3),
-				ViewVolume .unProjectPointMatrix (x2, y1, 0, matrix, viewport, p4),
-				ViewVolume .unProjectPointMatrix (x2, y2, 0, matrix, viewport, p5),
-				ViewVolume .unProjectPointMatrix (x2, y2, 1, matrix, viewport, p6);
-
-				this .planes [0] .set (p4, Triangle3 .normal (p3, p4, p5, normal));  // front
-				this .planes [1] .set (p2, Triangle3 .normal (p1, p2, p3, normal));  // left
-				this .planes [2] .set (p5, Triangle3 .normal (p6, p5, p4, normal));  // right
-				this .planes [3] .set (p6, Triangle3 .normal (p5, p6, p1, normal));  // top
-				this .planes [4] .set (p3, Triangle3 .normal (p4, p3, p2, normal));  // bottom
-				this .planes [5] .set (p1, Triangle3 .normal (p2, p1, p6, normal));  // back  
-
-				this .valid = true;
-			}
-			catch (error)
+			const matrix = new Matrix4 ();
+
+			return function (projectionMatrix, viewport, scissor)
 			{
-				this .valid = false;
-				//console .log (error);
-			}
+				try
+				{
+					this .viewport .assign (viewport);
+					this .scissor  .assign (scissor);
 
-			return this;
-		},
+					const points = this .points;
+
+					const
+						p0 = points [0],
+						p1 = points [1],
+						p2 = points [2],
+						p3 = points [3],
+						p4 = points [4],
+						p5 = points [5],
+						p6 = points [6],
+						p7 = points [7];
+
+					const
+						x1 = scissor [0],
+						x2 = x1 + scissor [2],
+						y1 = scissor [1],
+						y2 = y1 + scissor [3];
+
+					matrix .assign (projectionMatrix) .inverse ();
+
+					ViewVolume .unProjectPointMatrix (x1, y1, 0, matrix, viewport, p0),
+					ViewVolume .unProjectPointMatrix (x2, y1, 0, matrix, viewport, p1),
+					ViewVolume .unProjectPointMatrix (x2, y2, 0, matrix, viewport, p2),
+					ViewVolume .unProjectPointMatrix (x1, y2, 0, matrix, viewport, p3),
+					ViewVolume .unProjectPointMatrix (x1, y1, 1, matrix, viewport, p4),
+					ViewVolume .unProjectPointMatrix (x2, y1, 1, matrix, viewport, p5);
+					ViewVolume .unProjectPointMatrix (x2, y2, 1, matrix, viewport, p6);
+					ViewVolume .unProjectPointMatrix (x1, y2, 1, matrix, viewport, p7);
+
+					const normals = this .normals;
+
+					Triangle3 .normal (p0, p1, p2, normals [0]); // front
+					Triangle3 .normal (p7, p4, p0, normals [1]); // left
+					Triangle3 .normal (p6, p2, p1, normals [2]); // right
+					Triangle3 .normal (p2, p6, p7, normals [3]); // top
+					Triangle3 .normal (p1, p0, p4, normals [4]); // bottom
+					Triangle3 .normal (p4, p7, p6, normals [5]); // back
+
+					const planes = this .planes;
+
+					planes [0] .set (p1, normals [0]); // front
+					planes [1] .set (p4, normals [1]); // left
+					planes [2] .set (p2, normals [2]); // right
+					planes [3] .set (p6, normals [3]); // top
+					planes [4] .set (p0, normals [4]); // bottom
+					planes [5] .set (p7, normals [5]); // back
+
+					this .edges .tainted = true;
+					this .valid          = true;
+				}
+				catch (error)
+				{
+					this .valid = false;
+					//console .log (error);
+				}
+
+				return this;
+			};
+		})(),
 		getViewport: function ()
 		{
 			return this .viewport;
@@ -137,95 +208,221 @@ function (Line3, Plane3, Triangle3, Vector3, Vector4, Matrix4)
 		{
 			return this .scissor;
 		},
+		getEdges: function ()
+		{
+			// Return suitable edges for SAT theorem.
+
+			const edges = this .edges;
+
+			if (edges .tainted)
+			{
+				const points = this .points;
+
+				edges [0] .assign (points [0]) .subtract (points [1]);
+				edges [1] .assign (points [1]) .subtract (points [2]);
+				edges [2] .assign (points [2]) .subtract (points [3]);
+				edges [3] .assign (points [3]) .subtract (points [0]);
+
+				edges [4] .assign (points [0]) .subtract (points [4]);
+				edges [5] .assign (points [1]) .subtract (points [5]);
+				edges [6] .assign (points [2]) .subtract (points [6]);
+				edges [7] .assign (points [3]) .subtract (points [7]);
+
+				// Edges 8 - 11 are equal to edges 0 - 3.
+
+				edges .tainted = false;
+			}
+
+			return edges;
+		},
 		intersectsSphere: function (radius, center)
 		{
 			if (this .valid)
 			{
-				var planes = this .planes;
-			
+				const planes = this .planes;
+
 				if (planes [0] .getDistanceToPoint (center) > radius)
 					return false;
-	
+
 				if (planes [1] .getDistanceToPoint (center) > radius)
 					return false;
-	
+
 				if (planes [2] .getDistanceToPoint (center) > radius)
 					return false;
-	
+
 				if (planes [3] .getDistanceToPoint (center) > radius)
 					return false;
-	
+
 				if (planes [4] .getDistanceToPoint (center) > radius)
 					return false;
-	
+
 				if (planes [5] .getDistanceToPoint (center) > radius)
 					return false;
 			}
 
 			return true;
 		},
+		intersectsBox: (function ()
+		{
+			const points1 = [
+				new Vector3 (0, 0, 0),
+				new Vector3 (0, 0, 0),
+				new Vector3 (0, 0, 0),
+				new Vector3 (0, 0, 0),
+
+				new Vector3 (0, 0, 0),
+				new Vector3 (0, 0, 0),
+				new Vector3 (0, 0, 0),
+				new Vector3 (0, 0, 0),
+			];
+
+			const normals1 = [
+				new Vector3 (0, 0, 0),
+				new Vector3 (0, 0, 0),
+				new Vector3 (0, 0, 0),
+			];
+
+			const axes1 = [
+				new Vector3 (0, 0, 0),
+				new Vector3 (0, 0, 0),
+				new Vector3 (0, 0, 0),
+			];
+
+			const axes = [ ];
+
+			for (let i = 0; i < 3 * 8; ++ i)
+				axes .push (new Vector3 (0, 0, 0));
+
+			return function (box)
+			{
+				// Get points.
+
+				box .getPoints (points1);
+
+				const points2 = this .points;
+
+				// Test the three planes spanned by the normal vectors of the faces of the box.
+
+				if (SAT .isSeparated (box .getNormals (normals1), points1, points2))
+					return false;
+
+				// Test the six planes spanned by the normal vectors of the faces of the view volume.
+
+				if (SAT .isSeparated (this .normals, points1, points2))
+					return false;
+
+				// Test the planes spanned by the edges of each object.
+
+				box .getAxes (axes1);
+
+				const edges = this .getEdges ();
+
+				for (let i1 = 0; i1 < 3; ++ i1)
+				{
+					for (let i2 = 0; i2 < 8; ++ i2)
+						axes [i1 * 3 + i2] .assign (axes1 [i1]) .cross (edges [i2]);
+				}
+
+				if (SAT .isSeparated (axes, points1, points2))
+					return false;
+
+				// Both boxes intersect.
+
+				return true;
+			};
+		})(),
 	};
 
 	Object .assign (ViewVolume,
 	{
-		unProjectPoint: function (winx, winy, winz, modelViewMatrix, projectionMatrix, viewport, point)
+		unProjectPoint: (function ()
 		{
-			matrix .assign (modelViewMatrix) .multRight (projectionMatrix) .inverse ();
+			const matrix = new Matrix4 ();
 
-			return this .unProjectPointMatrix (winx, winy, winz, matrix, viewport, point);
-		},
-		unProjectPointMatrix: function (winx, winy, winz, invModelViewProjection, viewport, point)
+			return function (winx, winy, winz, modelViewMatrix, projectionMatrix, viewport, point)
+			{
+				matrix .assign (modelViewMatrix) .multRight (projectionMatrix) .inverse ();
+
+				return this .unProjectPointMatrix (winx, winy, winz, matrix, viewport, point);
+			};
+		})(),
+		unProjectPointMatrix: (function ()
 		{
-			// Transformation of normalized coordinates between -1 and 1
-			vin .set ((winx - viewport [0]) / viewport [2] * 2 - 1,
-			          (winy - viewport [1]) / viewport [3] * 2 - 1,
-			          2 * winz - 1,
-			          1);
+			const vin = new Vector4 (0, 0, 0, 0);
 
-			//Objects coordinates
-			invModelViewProjection .multVecMatrix (vin);
+			return function (winx, winy, winz, invModelViewProjection, viewport, point)
+			{
+				// Transformation of normalized coordinates between -1 and 1
+				vin .set ((winx - viewport [0]) / viewport [2] * 2 - 1,
+				          (winy - viewport [1]) / viewport [3] * 2 - 1,
+				          2 * winz - 1,
+				          1);
 
-			if (vin .w === 0)
-				throw new Error ("Couldn't unproject point: divisor is 0.");
+				//Objects coordinates
+				invModelViewProjection .multVecMatrix (vin);
 
-			var d = 1 / vin .w;
+				if (vin .w === 0)
+					throw new Error ("Couldn't unproject point: divisor is 0.");
 
-			return point .set (vin .x * d, vin .y * d, vin .z * d);
-		},
-		unProjectRay: function (winx, winy, modelViewMatrix, projectionMatrix, viewport, result)
+				const d = 1 / vin .w;
+
+				return point .set (vin .x * d, vin .y * d, vin .z * d);
+			};
+		})(),
+		unProjectRay: (function ()
 		{
-			matrix .assign (modelViewMatrix) .multRight (projectionMatrix) .inverse ();
+			const
+				near   = new Vector3 (0, 0, 0),
+				far    = new Vector3 (0, 0, 0),
+				matrix = new Matrix4 ();
 
-			ViewVolume .unProjectPointMatrix (winx, winy, 0.0, matrix, viewport, near);
-			ViewVolume .unProjectPointMatrix (winx, winy, 0.9, matrix, viewport, far);
+			return function (winx, winy, modelViewMatrix, projectionMatrix, viewport, result)
+			{
+				matrix .assign (modelViewMatrix) .multRight (projectionMatrix) .inverse ();
 
-			return result .setPoints (near, far);
-		},
-		projectPoint: function (point, modelViewMatrix, projectionMatrix, viewport, vout)
+				ViewVolume .unProjectPointMatrix (winx, winy, 0.0, matrix, viewport, near);
+				ViewVolume .unProjectPointMatrix (winx, winy, 0.9, matrix, viewport, far);
+
+				return result .setPoints (near, far);
+			};
+		})(),
+		projectPoint: (function ()
 		{
-			vin .set (point .x, point .y, point .z, 1);
+			const vin = new Vector4 (0, 0, 0, 0);
+
+			return function (point, modelViewMatrix, projectionMatrix, viewport, vout)
+			{
+				vin .set (point .x, point .y, point .z, 1);
 
-			projectionMatrix .multVecMatrix (modelViewMatrix .multVecMatrix (vin));
+				projectionMatrix .multVecMatrix (modelViewMatrix .multVecMatrix (vin));
 
-			if (vin .w === 0)
-				throw new Error ("Couldn't project point: divisor is 0.");
+				if (vin .w === 0)
+					throw new Error ("Couldn't project point: divisor is 0.");
 
-			var d = 1 / (2 * vin .w);
+				const d = 1 / (2 * vin .w);
 
-			return vout .set ((vin .x * d + 0.5) * viewport [2] + viewport [0],
-			                  (vin .y * d + 0.5) * viewport [3] + viewport [1],
-			                  (vin .z * d + 0.5));
-		},
-		projectLine: function (line, modelViewMatrix, projectionMatrix, viewport, result)
+				return vout .set ((vin .x * d + 0.5) * viewport [2] + viewport [0],
+				                  (vin .y * d + 0.5) * viewport [3] + viewport [1],
+				                  (vin .z * d + 0.5));
+			};
+		})(),
+		projectLine: (function ()
 		{
-			ViewVolume .projectPoint (line .point, modelViewMatrix, projectionMatrix, viewport, near);
-			ViewVolume .projectPoint (Vector3 .multiply (line .direction, 1e9) .add (line .point), modelViewMatrix, projectionMatrix, viewport, far);
+			const
+				near = new Vector3 (0, 0, 0),
+				far  = new Vector3 (0, 0, 0);
 
-			near .z = 0;
-			far  .z = 0;
+			return function (line, modelViewMatrix, projectionMatrix, viewport, result)
+			{
+				ViewVolume .projectPoint (line .point, modelViewMatrix, projectionMatrix, viewport, near);
+				ViewVolume .projectPoint (Vector3 .multiply (line .direction, 1e9) .add (line .point), modelViewMatrix, projectionMatrix, viewport, far);
 
-			return result .setPoints (near, far);
-		},
+				near .z = 0;
+				far  .z = 0;
+
+				return result .setPoints (near, far);
+			};
+		})(),
 	});
 
 	return ViewVolume;