x_ite 4.0.5 → 4.7.5

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

@@ -48,88 +48,158 @@
 
 
 define ([
-	"jquery",
-	"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)
-			{
-				this .valid = false;
-				console .log (error);
-			}
+			const matrix = new Matrix4 ();
 
-			return this;
-		},
+			return function (projectionMatrix, viewport, scissor)
+			{
+				try
+				{
+					this .viewport .assign (viewport);
+					this .scissor  .assign (scissor);
+
+					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;
@@ -138,92 +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)
 		{
-			var planes = this .planes;
-		
-			if (planes [0] .getDistanceToPoint (center) > radius)
-				return false;
+			if (this .valid)
+			{
+				const planes = this .planes;
+
+				if (planes [0] .getDistanceToPoint (center) > radius)
+					return false;
 
-			if (planes [1] .getDistanceToPoint (center) > radius)
-				return false;
+				if (planes [1] .getDistanceToPoint (center) > radius)
+					return false;
 
-			if (planes [2] .getDistanceToPoint (center) > radius)
-				return false;
+				if (planes [2] .getDistanceToPoint (center) > radius)
+					return false;
 
-			if (planes [3] .getDistanceToPoint (center) > radius)
-				return false;
+				if (planes [3] .getDistanceToPoint (center) > radius)
+					return false;
 
-			if (planes [4] .getDistanceToPoint (center) > radius)
-				return false;
+				if (planes [4] .getDistanceToPoint (center) > radius)
+					return false;
 
-			if (planes [5] .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;
+			};
+		})(),
 	};
 
-	$.extend (ViewVolume,
+	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);
+
+			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);
 
-			//Objects coordinates
-			invModelViewProjection .multVecMatrix (vin);
+				//Objects coordinates
+				invModelViewProjection .multVecMatrix (vin);
 
-			if (vin .w === 0)
-				throw new Error ("Couldn't unproject point: divisor is 0.");
+				if (vin .w === 0)
+					throw new Error ("Couldn't unproject point: divisor is 0.");
 
-			var d = 1 / vin .w;
+				const d = 1 / vin .w;
 
-			return point .set (vin .x * d, vin .y * d, vin .z * d);
-		},
-		unProjectRay: function (winx, winy, modelViewMatrix, projectionMatrix, viewport, result)
+				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;

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

@@ -48,14 +48,13 @@
 
 
 define ([
-	"jquery",
 	"standard/Math/Algorithm",
 ],
-function ($, Algorithm)
+function (Algorithm)
 {
 "use strict";
 
-	var clamp = Algorithm .clamp;
+	const clamp = Algorithm .clamp;
 
 	function Color3 (r, g, b)
 	{
@@ -79,7 +78,7 @@ function ($, Algorithm)
 		length: 3,
 		copy: function ()
 		{
-			var copy = Object .create (Color3 .prototype);
+			const copy = Object .create (Color3 .prototype);
 			copy .r_ = this .r_;
 			copy .g_ = this .g_;
 			copy .b_ = this .b_;
@@ -105,13 +104,13 @@ function ($, Algorithm)
 		},
 		getHSV: function (result)
 		{
-			var h, s, v;
+			let h, s, v;
 
-			var min = Math .min (this .r_, this .g_, this .b_);
-			var max = Math .max (this .r_, this .g_, this .b_);
+			const min = Math .min (this .r_, this .g_, this .b_);
+			const max = Math .max (this .r_, this .g_, this .b_);
 			v = max; // value
 
-			var delta = max - min;
+			const delta = max - min;
 
 			if (max !== 0 && delta !== 0)
 			{
@@ -152,13 +151,13 @@ function ($, Algorithm)
 			}
 			else
 			{
-				var w = Algorithm .degrees (Algorithm .interval (h, 0, Math .PI * 2)) / 60;     // sector 0 to 5
+				const w = Algorithm .degrees (Algorithm .interval (h, 0, Math .PI * 2)) / 60;     // sector 0 to 5
 
-				var i = Math .floor (w);
-				var f = w - i;                      // factorial part of h
-				var p = v * ( 1 - s );
-				var q = v * ( 1 - s * f );
-				var t = v * ( 1 - s * ( 1 - f ) );
+				const i = Math .floor (w);
+				const f = w - i;                      // factorial part of h
+				const p = v * ( 1 - s );
+				const q = v * ( 1 - s * f );
+				const t = v * ( 1 - s * ( 1 - f ) );
 
 				switch (i % 6)
 				{
@@ -179,21 +178,21 @@ function ($, Algorithm)
 		},
 	};
 
-	var r = {
+	const r = {
 		get: function () { return this .r_; },
 		set: function (value) { this .r_ = clamp (value, 0, 1); },
 		enumerable: true,
 		configurable: false
 	};
-	
-	var g = {
+
+	const g = {
 		get: function () { return this .g_; },
 		set: function (value) { this .g_ = clamp (value, 0, 1); },
 		enumerable: true,
 		configurable: false
 	};
 
-	var b = {
+	const b = {
 		get: function () { return this .b_; },
 		set: function (value) { this .b_ = clamp (value, 0, 1); },
 		enumerable: true,
@@ -212,30 +211,47 @@ function ($, Algorithm)
 	Object .defineProperty (Color3 .prototype, "1", g);
 	Object .defineProperty (Color3 .prototype, "2", b);
 
-	$.extend (Color3,
+	Object .assign (Color3,
 	{
 		HSV: function (h, s, v)
 		{
-			var color = new Color3 (0, 0, 0);
+			const color = Object .create (this .prototype);
 			color .setHSV (h, s, v);
 			return color;
 		},
 		lerp: function (a, b, t, r)
 		{
-			var range = Math .abs (b [0] - a [0]);
+			// Linearely interpolate in HSV space between source color @a a and destination color @a b by an amount of @a t.
+			// Source and destination color must be in HSV space. The resulting HSV color is stored in @a r.
+
+			let
+				ha = a [0], hb = b [0];
+
+			const
+				sa = a [1], sb = b [1],
+				va = a [2], vb = b [2];
+
+			if (sa === 0)
+				ha = hb;
+
+			if (sb === 0)
+				hb = ha;
+
+			const range = Math .abs (hb - ha);
 
 			if (range <= Math .PI)
 			{
-				r [0] = Algorithm .lerp (a [0], b [0], t);
-				r [1] = Algorithm .lerp (a [1], b [1], t);
-				r [2] = Algorithm .lerp (a [2], b [2], t);
+				r [0] = ha + t * (hb - ha);
+				r [1] = sa + t * (sb - sa);
+				r [2] = va + t * (vb - va);
 				return r;
 			}
 
-			var
+			const
 				PI2  = Math .PI * 2,
-				step = (PI2 - range) * t,
-				h    = a [0] < b [0] ? a [0] - step : a [0] + step;
+				step = (PI2 - range) * t;
+
+			let h = ha < hb ? ha - step : ha + step;
 
 			if (h < 0)
 				h += PI2;
@@ -244,8 +260,8 @@ function ($, Algorithm)
 				h -= PI2;
 
 			r [0] = h;
-			r [1] = Algorithm .lerp (a [1], b [1], t);
-			r [2] = Algorithm .lerp (a [2], b [2], t);
+			r [1] = sa + t * (sb - sa);
+			r [2] = va + t * (vb - va);
 			return r;
 		},
 	});