x_ite 4.2.17 → 4.7.7

package/src/standard/Math/Algorithm.js

@@ -51,12 +51,11 @@ define (function ()
 {
 "use strict";
 
-	var Algorithm =
+	function Algorithm () { }
+
+	Algorithm .prototype =
 	{
-		signum: function (value)
-		{
-			return (0 < value) - (value < 0);
-		},
+		constructor: Algorithm,
 		radians: function (value)
 		{
 			return value * (Math .PI / 180);
@@ -69,6 +68,10 @@ define (function ()
 		{
 			return min + Math .random () * (max - min);
 		},
+		fract: function (value)
+		{
+			return value > 0 ? value - Math .floor (value) : value - Math .ceil (value);
+		},
 		clamp: function (value, min, max)
 		{
 			// http://jsperf.com/math-clamp
@@ -91,7 +94,7 @@ define (function ()
 		},
 		slerp: function (source, destination, t)
 		{
-			var cosom = source .dot (destination);
+			let cosom = source .dot (destination);
 
 			if (cosom <= -1)
 				throw new Error ("slerp is not possible: vectors are inverse collinear.");
@@ -104,9 +107,9 @@ define (function ()
 				// Reverse signs so we travel the short way round
 				cosom = -cosom;
 				destination .negate ();
-			}				
+			}
 
-			var
+			const
 				omega = Math .acos (cosom),
 				sinom = Math .sin  (omega),
 
@@ -122,7 +125,7 @@ define (function ()
 		},
 		simpleSlerp: function (source, destination, t)
 		{
-			var cosom = source .dot (destination);
+			const cosom = source .dot (destination);
 
 			if (cosom <= -1)
 				throw new Error ("slerp is not possible: vectors are inverse collinear.");
@@ -130,7 +133,7 @@ define (function ()
 			if (cosom >= 1) // both normal vectors are equal
 				return source;
 
-			var
+			const
 				omega = Math .acos (cosom),
 				sinom = Math .sin  (omega),
 
@@ -152,31 +155,15 @@ define (function ()
 		{
 			///  Returns the next power of two of @a n. If n is a power of two, n is returned.
 
-			-- n;
-
-			for (var k = 1; ! (k & (1 << (4 + 1))); k <<= 1)
-				n |= n >> k;
+			if (this .isPowerOfTwo (n))
+				return n;
 
-			return ++ n;
+			return 1 << 32 - Math .clz32 (n);
 		},
-		/*
-		isInt: function(n)
+		cmp: function (lhs, rhs)
 		{
-			return typeof n === 'number' && 
-			       parseFloat (n) == parseInt (n, 10) && ! isNaN (n);
+			return lhs > rhs ? 1 : lhs < rhs ? -1 : 0;
 		},
-		decimalPlaces: function (n)
-		{
-			var
-				a = Math.abs(n),
-				c = a, count = 1;
-
-			while(! Algorithm .isInt (c) && isFinite (c))
-				c = a * Math .pow (10, count ++);
-	
-			return count-1;
-		},
-		*/
 		less: function (lhs, rhs)
 		{
 			return lhs < rhs;
@@ -189,7 +176,7 @@ define (function ()
 		{
 		   // http://en.cppreference.com/w/cpp/algorithm/lower_bound
 
-			var
+			let
 				index = 0,
 				step  = 0,
 				count = last - first;
@@ -214,7 +201,7 @@ define (function ()
 		{
 		   // http://en.cppreference.com/w/cpp/algorithm/upper_bound
 
-			var
+			let
 				index = 0,
 				step  = 0,
 				count = last - first;
@@ -238,7 +225,7 @@ define (function ()
 		},
 		set_difference: function (lhs, rhs, result)
 		{
-			for (var key in lhs)
+			for (const key in lhs)
 			{
 				if (key in rhs)
 					continue;
@@ -250,9 +237,5 @@ define (function ()
 		},
 	};
 
-	Object .preventExtensions (Algorithm);
-	Object .freeze (Algorithm);
-	Object .seal (Algorithm);
-
-	return Algorithm;
+	return new Algorithm ();
 });

package/src/standard/Math/Algorithms/Bezier.js

@@ -0,0 +1,147 @@
+/* -*- Mode: JavaScript; coding: utf-8; tab-width: 3; indent-tabs-mode: tab; c-basic-offset: 3 -*-
+ *******************************************************************************
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright create3000, Scheffelstraße 31a, Leipzig, Germany 2011.
+ *
+ * All rights reserved. Holger Seelig <holger.seelig@yahoo.de>.
+ *
+ * The copyright notice above does not evidence any actual of intended
+ * publication of such source code, and is an unpublished work by create3000.
+ * This material contains CONFIDENTIAL INFORMATION that is the property of
+ * create3000.
+ *
+ * No permission is granted to copy, distribute, or create derivative works from
+ * the contents of this software, in whole or in part, without the prior written
+ * permission of create3000.
+ *
+ * NON-MILITARY USE ONLY
+ *
+ * All create3000 software are effectively free software with a non-military use
+ * restriction. It is free. Well commented source is provided. You may reuse the
+ * source in any way you please with the exception anything that uses it must be
+ * marked to indicate is contains 'non-military use only' components.
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2015, 2016 Holger Seelig <holger.seelig@yahoo.de>.
+ *
+ * This file is part of the X_ITE Project.
+ *
+ * X_ITE is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License version 3 only, as published by the
+ * Free Software Foundation.
+ *
+ * X_ITE is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the GNU General Public License version 3 for more
+ * details (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version 3
+ * along with X_ITE.  If not, see <http://www.gnu.org/licenses/gpl.html> for a
+ * copy of the GPLv3 License.
+ *
+ * For Silvio, Joy and Adi.
+ *
+ ******************************************************************************/
+
+
+define ([
+	"standard/Math/Algorithm",
+],
+function (Algorithm)
+{
+	"use strict";
+
+	const lerp = Algorithm .lerp;
+
+	function Bezier (x0, y0, x1, y1, x2, y2, x3, y3)
+	{
+		this .x0 = x0;
+		this .y0 = y0;
+		this .x1 = x1;
+		this .y1 = y1;
+		this .x2 = x2;
+		this .y2 = y2;
+		this .x3 = x3;
+		this .y3 = y3;
+
+		this .order = arguments .length / 2 - 1;
+	}
+
+	Bezier .prototype =
+	{
+		getLUT: function (dimension)
+		{
+			const
+				x0  = this .x0,
+				y0  = this .y0,
+				x1  = this .x1,
+				y1  = this .y1,
+				x2  = this .x2,
+				y2  = this .y2,
+				x3  = this .x3,
+				y3  = this .y3,
+				lut = [ ];
+
+			switch (this .order)
+			{
+				case 2:
+				{
+					for (let i = 0, d = dimension - 1; i < dimension; ++ i)
+					{
+						lut .push (quadric (x0, y0, x1, y1, x2, y2, i / d));
+					}
+
+					break;
+				}
+				case 3:
+				{
+					for (let i = 0, d = dimension - 1; i < dimension; ++ i)
+					{
+						lut .push (cubic (x0, y0, x1, y1, x2, y2, x3, y3, i / d));
+					}
+
+					break;
+				}
+			}
+
+			return lut;
+		}
+	};
+
+	function quadric (x0, y0, x1, y1, x2, y2, t)
+	{
+		const
+			ax0 = lerp (x0, x1, t),
+			ay0 = lerp (y0, y1, t),
+			ax1 = lerp (x1, x2, t),
+			ay1 = lerp (y1, y2, t),
+			bx0 = lerp (ax0, ax1, t),
+			by0 = lerp (ay0, ay1, t);
+
+		return {x: bx0, y: by0};
+	}
+
+	function cubic (x0, y0, x1, y1, x2, y2, x3, y3, t)
+	{
+		const
+			ax0 = lerp (x0, x1, t),
+			ay0 = lerp (y0, y1, t),
+			ax1 = lerp (x1, x2, t),
+			ay1 = lerp (y1, y2, t),
+			ax2 = lerp (x2, x3, t),
+			ay2 = lerp (y2, y3, t),
+			bx0 = lerp (ax0, ax1, t),
+			by0 = lerp (ay0, ay1, t),
+			bx1 = lerp (ax1, ax2, t),
+			by1 = lerp (ay1, ay2, t),
+			cx0 = lerp (bx0, bx1, t),
+			cy0 = lerp (by0, by1, t);
+
+		return {x: cx0, y: cy0};
+	}
+
+ 	return Bezier;
+});

package/src/standard/Math/Algorithms/MergeSort.js

@@ -74,7 +74,7 @@ define (function ()
 		{
 			if (lo < hi)
 			{
-				var m = (lo + hi) >>> 1;
+				const m = (lo + hi) >>> 1;
 				this .mergeSort (lo, m);   // Recursion
 				this .mergeSort (m + 1, hi); // Recursion
 				this .merge (lo, m, hi);
@@ -82,7 +82,7 @@ define (function ()
 		},
 		merge: function (lo, m, hi)
 		{
-			var i, j, k;
+			let i, j, k;
 
 			i = 0, j = lo;
 			// Copy first half of array a to auxiliary array b.

package/src/standard/Math/Algorithms/PartialSort.js

@@ -51,12 +51,12 @@ define (function ()
 {
 "use strict";
 
-	var shrinkFactor = 1 - Math .pow (Math .E, -Math .PHI); // 0.801711847137793
+	const shrinkFactor = 1 - Math .exp (-Math .PHI); // 0.801711847137793
 
 	function PartialSort (array, compare)
 	{
 		this .array = array;
-		
+
 		if (compare)
 			this .compare = compare;
 	}
@@ -74,18 +74,18 @@ define (function ()
 		},
 		partialsort: function (lo, hi)
 		{
-			var gap = this .last, i, last;
+			let gap = this .last, i, last;
 
 			if (gap > 1)
 				gap = Math .floor (gap * shrinkFactor);
-				
+
 			for (i = 0, last = this .last - gap; i < last; ++ i)
 			{
-				var j = i + gap;
+				const j = i + gap;
 
 				if (this .compare (this .array [j], this .array [i]))
 				{
-					var t = array [i];
+					const t = array [i];
 					array [i] = array [j];
 					array [j] = t;
 				}

package/src/standard/Math/Algorithms/QuickSort.js

@@ -54,7 +54,7 @@ define (function ()
 	function QuickSort (array, compare)
 	{
 		this .array = array;
-		
+
 		if (compare)
 			this .compare = compare;
 	}
@@ -72,14 +72,16 @@ define (function ()
 		},
 		quicksort: function (lo, hi)
 		{
-			var
+			let
 				i = lo,
-				j = hi,
+				j = hi;
+
+			const
 				array   = this .array,
 				compare = this .compare;
 
 			// Vergleichs­element x
-			var x = array [(lo + hi) >>> 1];
+			const x = array [(lo + hi) >>> 1];
 
 			for (;;)
 			{
@@ -89,8 +91,8 @@ define (function ()
 				if (i < j)
 				{
 					// Exchange
-					
-					var t = array [i];
+
+					const t = array [i];
 					array [i] = array [j];
 					array [j] = t;
 

package/src/standard/Math/Algorithms/SAT.js

@@ -51,7 +51,7 @@ define (function ()
 {
 "use strict";
 
-	var
+	const
 		extents1 = { min: 0, max: 0 },
 		extents2 = { min: 0, max: 0 };
 
@@ -64,10 +64,8 @@ define (function ()
 	{
 		// http://gamedev.stackexchange.com/questions/25397/obb-vs-obb-collision-detection
 
-		for (var i = 0, length = axes .length; i < length; ++ i)
+		for (const axis of axes)
 		{
-			var axis = axes [i];
-
 			project (points1, axis, extents1);
 			project (points2, axis, extents2);
 
@@ -86,15 +84,13 @@ define (function ()
 		extents .min = Number .POSITIVE_INFINITY;
 		extents .max = Number .NEGATIVE_INFINITY;
 
-		for (var i = 0, length = points .length; i < length; ++ i)
+		for (const point of points)
 		{
-			var point = points [i];
-
 			// Just dot it to get the min and max along this axis.
 			// NOTE: the axis must be normalized to get accurate projections to calculate the MTV, but if it is only needed to
 			// know whether it overlaps, every axis can be used.
 
-			var dotVal = point .dot (axis);
+			const dotVal = point .dot (axis);
 
 			if (dotVal < extents .min)
 				extents .min = dotVal;

package/src/standard/Math/Algorithms/eigendecomposition.js

@@ -51,37 +51,37 @@ define (function ()
 {
 "use strict";
 
+	const a = [ ]; // more scratch
+	const b = [ ]; // more scratch
+	const z = [ ]; // more scratch
+
 	// Calculate eigenvalues and eigenvectors.
 	// This is from SGI Inventor Matrix.cpp.
-	return function (matrix)
+	return function (matrix, result)
 	{
-		var
+		const
 			ORDER   = matrix .order,
-			values  = new Array (ORDER),
-			vectors = new Array (ORDER);
-
-		var sm;                // smallest entry
-		var theta;             // angle for Jacobi rotation
-		var c, s, t;           // cosine, sine, tangent of theta
-		var tau;               // sine / (1 + cos)
-		var h, g;              // two scrap values
-		var thresh;            // threshold below which no rotation done
-		var a = new Array (ORDER);
-		var b = new Array (ORDER); // more scratch
-		var z = new Array (ORDER); // more scratch
-		var p, q, i, j;
-		var SIZE = matrix .length;
+			values  = result .values,
+			vectors = result .vectors;
+
+		let
+			sm,                // smallest entry
+			theta,             // angle for Jacobi rotation
+			c, s, t,           // cosine, sine, tangent of theta
+			tau,               // sine / (1 + cos)
+			h, g,              // two scrap values
+			thresh,            // threshold below which no rotation done
+			p, q, i, j,
+			SIZE = matrix .length;
 
 		// initializations
-		for (i = 0; i < ORDER; ++i)
+		for (i = 0; i < ORDER; ++ i)
 		{
-			vectors [i] = new Array (ORDER);
-
-			a [i] = new Array (ORDER);
+			a [i] = a [i] || new Array (ORDER);
 			b [i] = values [i] = matrix .get1 (i, i);
 			z [i] = 0;
 
-			for (j = 0; j < ORDER; ++j)
+			for (j = 0; j < ORDER; ++ j)
 			{
 				vectors [i] [j] = (i === j) ? 1 : 0;
 				a [i] [j] = matrix .get1 (j, i);
@@ -90,13 +90,15 @@ define (function ()
 
 		// Why 50? I don't know--it's the way the folks who wrote the
 		// algorithm did it:
-		for (i = 0; i < 50; ++i)
+		for (i = 0; i < 50; ++ i)
 		{
 			sm = 0;
 
-			for (p = 0; p < ORDER - 1; ++p)
-				for (q = p+1; q < ORDER; ++q)
+			for (p = 0; p < ORDER - 1; ++ p)
+			{
+				for (q = p + 1; q < ORDER; ++ q)
 					sm += Math .abs (a [p] [q]);
+			}
 
 			if (sm === 0)
 				break;
@@ -105,9 +107,9 @@ define (function ()
 				0.2 * sm / SIZE :
 				0;
 
-			for (p = 0; p < ORDER - 1; ++p)
+			for (p = 0; p < ORDER - 1; ++ p)
 			{
-				for (q = p+1; q < ORDER; ++q)
+				for (q = p + 1; q < ORDER; ++ q)
 				{
 					g = 100 * Math .abs (a [p] [q]);
 
@@ -124,7 +126,9 @@ define (function ()
 						h = values [q] - values [p];
 
 						if (Math .abs (h) + g === Math .abs (h))
+						{
 							t = a [p] [q] / h;
+						}
 						else
 						{
 							theta = 0.5 * h / a [p] [q];
@@ -134,7 +138,7 @@ define (function ()
 						}
 						// End of computing tangent of rotation angle
 
-						c           = 1 / Math .sqrt (1 + t*t);
+						c           = 1 / Math .sqrt (1 + t * t);
 						s           = t * c;
 						tau         = s / (1 + c);
 						h           = t * a [p] [q];
@@ -144,7 +148,7 @@ define (function ()
 						values [q] += h;
 						a [p] [q]   = 0;
 
-						for (j = 0; j < p; ++j)
+						for (j = 0; j < p; ++ j)
 						{
 							g = a [j] [p];
 							h = a [j] [q];
@@ -152,7 +156,7 @@ define (function ()
 							a [j] [q] = h + s * (g - h * tau);
 						}
 
-						for (j = p+1; j < q; ++j)
+						for (j = p + 1; j < q; ++ j)
 						{
 							g = a [p] [j];
 							h = a [j] [q];
@@ -160,7 +164,7 @@ define (function ()
 							a [j] [q] = h + s * (g - h * tau);
 						}
 
-						for (j = q+1; j < ORDER; ++j)
+						for (j = q + 1; j < ORDER; ++ j)
 						{
 							g = a [p] [j];
 							h = a [q] [j];
@@ -168,7 +172,7 @@ define (function ()
 							a [q] [j] = h + s * (g - h * tau);
 						}
 
-						for (j = 0; j < ORDER; ++j)
+						for (j = 0; j < ORDER; ++ j)
 						{
 							g = vectors [j] [p];
 							h = vectors [j] [q];
@@ -179,13 +183,13 @@ define (function ()
 				}
 			}
 
-			for (p = 0; p < ORDER; ++p)
+			for (p = 0; p < ORDER; ++ p)
 			{
 				values [p] = b [p] += z [p];
 				z [p] = 0;
 			}
 		}
 
-		return { values: values, vectors: vectors };
+		return result;
 	};
 });