x_ite 4.7.12 → 5.0.0

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

@@ -48,163 +48,198 @@
 
 
 define ([
-	"standard/Math/Numbers/Vector3",
+   "standard/Math/Numbers/Vector3",
 ],
 function (Vector3)
 {
 "use strict";
 
-	function Line3 (point, direction)
-	{
-		this .point     = point     .copy ();
-		this .direction = direction .copy ();
-	}
-
-	Line3 .prototype =
-	{
-		constructor: Line3,
-		copy: function ()
-		{
-			const copy = Object .create (Line3 .prototype);
-			copy .point     = this .point .copy ();
-			copy .direction = this .direction .copy ();
-			return copy;
-		},
-		assign: function (line)
-		{
-			this .point     .assign (line .point);
-			this .direction .assign (line .direction);
-			return this;
-		},
-		set: function (point, direction)
-		{
-			this .point     .assign (point);
-			this .direction .assign (direction);
-			return this;
-		},
-		setPoints: function (point1, point2)
-		{
-			this .point .assign (point1);
-			this .direction .assign (point2) .subtract (point1) .normalize ();
-			return this;
-		},
-		multMatrixLine: function (matrix)
-		{
-			matrix .multMatrixVec (this .point);
-			matrix .multMatrixDir (this .direction) .normalize ();
-			return this;
-		},
-		multLineMatrix: function (matrix)
-		{
-			matrix .multVecMatrix (this .point);
-			matrix .multDirMatrix (this .direction) .normalize ();
-			return this;
-		},
-		getClosestPointToPoint: function (point, result)
-		{
-			const
-				r = result .assign (point) .subtract (this .point),
-				d = r .dot (this .direction);
-
-			return result .assign (this .direction) .multiply (d) .add (this .point);
-		},
-		getClosestPointToLine: (function ()
-		{
-			const u = new Vector3 (0, 0, 0);
-
-			return function (line, point)
-			{
-				const
-					p1 = this .point,
-					p2 = line .point,
-					d1 = this .direction,
-					d2 = line .direction;
-
-				let t = Vector3 .dot (d1, d2);
-
-				if (Math .abs (t) >= 1)
-					return false;  // lines are parallel
-
-				u .assign (p2) .subtract (p1);
-
-				t = (u .dot (d1) - t * u .dot (d2)) / (1 - t * t);
-
-				point .assign (d1) .multiply (t) .add (p1);
-				return true;
-			};
-		})(),
-		getPerpendicularVector: function (point)
-		{
-			const d = Vector3 .subtract (this .point, point);
-
-			return d .subtract (this .direction .copy () .multiply (Vector3 .dot (d, this .direction)));
-		},
-		intersectsTriangle: (function ()
-		{
-			const
-				pvec = new Vector3 (0, 0, 0),
-				tvec = new Vector3 (0, 0, 0);
-
-			return function (A, B, C, uvt)
-			{
-				// Find vectors for two edges sharing vert0.
-				const
-					edge1 = B .subtract (A),
-					edge2 = C .subtract (A);
-
-				// Begin calculating determinant - also used to calculate U parameter.
-				pvec .assign (this .direction) .cross (edge2);
-
-				// If determinant is near zero, ray lies in plane of triangle.
-				const det = edge1 .dot (pvec);
-
-				// Non culling intersection.
-
-				if (det === 0)
-					return false;
-
-					const inv_det = 1 / det;
-
-				// Calculate distance from vert0 to ray point.
-				tvec .assign (this .point) .subtract (A);
-
-				// Calculate U parameter and test bounds.
-				const u = tvec .dot (pvec) * inv_det;
-
-				if (u < 0 || u > 1)
-					return false;
-
-				// Prepare to test V parameter.
-				const qvec = tvec .cross (edge1);
-
-				// Calculate V parameter and test bounds.
-				const v = this .direction .dot (qvec) * inv_det;
-
-				if (v < 0 || u + v > 1)
-					return false;
-
-				//let t = edge2 .dot (qvec) * inv_det;
-
-				uvt .u = u;
-				uvt .v = v;
-				uvt .t = 1 - u - v;
-
-				return true;
-			};
-		})(),
-		toString: function ()
-		{
-			return this .point + ", " + this .direction;
-		},
-	};
-
-	Line3 .Points = function (point1, point2)
-	{
-		const line = Object .create (Line3 .prototype);
-		line .point     = point1 .copy ();
-		line .direction = Vector3 .subtract (point2, point1) .normalize ();
-		return line;
-	};
+   function Line3 (point, direction)
+   {
+      this .point     = point     .copy ();
+      this .direction = direction .copy ();
+   }
+
+   Line3 .prototype =
+   {
+      constructor: Line3,
+      copy: function ()
+      {
+         const copy = Object .create (Line3 .prototype);
+         copy .point     = this .point .copy ();
+         copy .direction = this .direction .copy ();
+         return copy;
+      },
+      assign: function (line)
+      {
+         this .point     .assign (line .point);
+         this .direction .assign (line .direction);
+         return this;
+      },
+      set: function (point, direction)
+      {
+         this .point     .assign (point);
+         this .direction .assign (direction);
+         return this;
+      },
+      setPoints: function (point1, point2)
+      {
+         this .point .assign (point1);
+         this .direction .assign (point2) .subtract (point1) .normalize ();
+         return this;
+      },
+      multMatrixLine: function (matrix)
+      {
+         matrix .multMatrixVec (this .point);
+         matrix .multMatrixDir (this .direction) .normalize ();
+         return this;
+      },
+      multLineMatrix: function (matrix)
+      {
+         matrix .multVecMatrix (this .point);
+         matrix .multDirMatrix (this .direction) .normalize ();
+         return this;
+      },
+      getClosestPointToPoint: function (point, result)
+      {
+         const
+            r = result .assign (point) .subtract (this .point),
+            d = r .dot (this .direction);
+
+         return result .assign (this .direction) .multiply (d) .add (this .point);
+      },
+      getClosestPointToLine: (function ()
+      {
+         const u = new Vector3 (0, 0, 0);
+
+         return function (line, point)
+         {
+            const
+               p1 = this .point,
+               p2 = line .point,
+               d1 = this .direction,
+               d2 = line .direction;
+
+            let t = Vector3 .dot (d1, d2);
+
+            if (Math .abs (t) >= 1)
+               return false;  // lines are parallel
+
+            u .assign (p2) .subtract (p1);
+
+            t = (u .dot (d1) - t * u .dot (d2)) / (1 - t * t);
+
+            point .assign (d1) .multiply (t) .add (p1);
+            return true;
+         };
+      })(),
+      getPerpendicularVectorToPoint: (function ()
+      {
+         const t = new Vector3 (0, 0, 0);
+
+         return function (point, result)
+         {
+            const d = result;
+
+            d .assign (this .point) .subtract (point);
+
+            return d .subtract (t .assign (this .direction) .multiply (d .dot (this .direction)));
+         };
+      })(),
+      getPerpendicularVectorToLine: (function ()
+      {
+         const
+            d  = new Vector3 (0, 0, 0),
+            ad = new Vector3 (0, 0, 0);
+
+         return function (line, result)
+         {
+            const bd = result;
+
+            d .assign (this .point) .subtract (line .point);
+
+            const
+               re1 = d .dot (this .direction),
+               re2 = d .dot (line .direction),
+               e12 = this .direction .dot (line .direction),
+               E12 = e12 * e12;
+
+            const
+               a =  (re1 - re2 * e12) / (1 - E12),
+               b = -(re2 - re1 * e12) / (1 - E12);
+
+            ad .assign (this .direction) .multiply (a);
+            bd .assign (line .direction) .multiply (b);
+
+            return bd .subtract (ad) .add (d);
+         };
+      })(),
+      intersectsTriangle: (function ()
+      {
+         const
+            pvec = new Vector3 (0, 0, 0),
+            tvec = new Vector3 (0, 0, 0);
+
+         return function (A, B, C, uvt)
+         {
+            // Find vectors for two edges sharing vert0.
+            const
+               edge1 = B .subtract (A),
+               edge2 = C .subtract (A);
+
+            // Begin calculating determinant - also used to calculate U parameter.
+            pvec .assign (this .direction) .cross (edge2);
+
+            // If determinant is near zero, ray lies in plane of triangle.
+            const det = edge1 .dot (pvec);
+
+            // Non culling intersection.
+
+            if (det === 0)
+               return false;
+
+               const inv_det = 1 / det;
+
+            // Calculate distance from vert0 to ray point.
+            tvec .assign (this .point) .subtract (A);
+
+            // Calculate U parameter and test bounds.
+            const u = tvec .dot (pvec) * inv_det;
+
+            if (u < 0 || u > 1)
+               return false;
+
+            // Prepare to test V parameter.
+            const qvec = tvec .cross (edge1);
 
-	return Line3;
+            // Calculate V parameter and test bounds.
+            const v = this .direction .dot (qvec) * inv_det;
+
+            if (v < 0 || u + v > 1)
+               return false;
+
+            //let t = edge2 .dot (qvec) * inv_det;
+
+            uvt .u = u;
+            uvt .v = v;
+            uvt .t = 1 - u - v;
+
+            return true;
+         };
+      })(),
+      toString: function ()
+      {
+         return this .point + ", " + this .direction;
+      },
+   };
+
+   Line3 .Points = function (point1, point2)
+   {
+      const line = Object .create (Line3 .prototype);
+      line .point     = point1 .copy ();
+      line .direction = Vector3 .subtract (point2, point1) .normalize ();
+      return line;
+   };
+
+   return Line3;
 });

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

@@ -48,130 +48,130 @@
 
 
 define ([
-	"standard/Math/Numbers/Vector3",
-	"standard/Math/Numbers/Matrix4",
+   "standard/Math/Numbers/Vector3",
+   "standard/Math/Numbers/Matrix4",
 ],
 function (Vector3,
           Matrix4)
 {
 "use strict";
 
-	const
-		normal    = new Vector3 (0, 0, 0),
-		point     = new Vector3 (0, 0, 0),
-		invMatrix = new Matrix4 ();
-
-	function Plane3 (point, normal)
-	{
-		this .normal             = normal .copy ();
-		this .distanceFromOrigin = normal .dot (point);
-	}
-
-	Plane3 .prototype =
-	{
-		constructor: Plane3,
-		copy: function ()
-		{
-			const copy = Object .create (Plane3 .prototype);
-			copy .normal             = this .normal .copy ();
-			copy .distanceFromOrigin = this .distanceFromOrigin;
-			return copy;
-		},
-		assign: function (plane)
-		{
-			this .normal .assign (plane .normal);
-			this .distanceFromOrigin = plane .distanceFromOrigin;
-			return this;
-		},
-		set: function (point, normal)
-		{
-			this .normal .assign (normal);
-			this .distanceFromOrigin = normal .dot (point);
-			return this;
-		},
-		multRight: function (matrix)
-		//throw
-		{
-			// Taken from Inventor:
-
-			// Find the point on the plane along the normal from the origin
-			point .assign (this .normal) .multiply (this .distanceFromOrigin);
-
-			// Transform the plane normal by the matrix
-			// to get the new normal. Use the inverse transpose
-			// of the matrix so that normals are not scaled incorrectly.
-			// n' = n * !~m = ~m * n
-			invMatrix .assign (matrix) .inverse ();
-			invMatrix .multMatrixDir (normal .assign (this .normal)) .normalize ();
-
-			// Transform the point by the matrix
-			matrix .multVecMatrix (point);
-
-			// The new distance is the projected distance of the vector to the
-			// transformed point onto the (unit) transformed normal. This is
-			// just a dot product.
-			this .normal .assign (normal);
-			this .distanceFromOrigin = normal .dot (point);
-
-			return this;
-		},
-		multLeft: function (matrix)
-		//throw
-		{
-			// Taken from Inventor:
-
-			// Find the point on the plane along the normal from the origin
-			point .assign (this .normal) .multiply (this .distanceFromOrigin);
-
-			// Transform the plane normal by the matrix
-			// to get the new normal. Use the inverse transpose
-			// of the matrix so that normals are not scaled incorrectly.
-			// n' = !~m * n = n * ~m
-			invMatrix .assign (matrix) .inverse ();
-			invMatrix .multDirMatrix (normal .assign (this .normal)) .normalize ();
-
-			// Transform the point by the matrix
-			matrix .multMatrixVec (point);
-
-			// The new distance is the projected distance of the vector to the
-			// transformed point onto the (unit) transformed normal. This is
-			// just a dot product.
-			this .normal .assign (normal);
-			this .distanceFromOrigin = normal .dot (point);
-
-			return this;
-		},
-		getDistanceToPoint: function (point)
-		{
-			return Vector3 .dot (point, this .normal) - this .distanceFromOrigin;
-		},
-		intersectsLine: function (line, intersection)
-		{
-			const
-				point     = line .point,
-				direction = line .direction;
-
-			// Check if the line is parallel to the plane.
-			const theta = direction .dot (this .normal);
-
-			// Plane and line are parallel.
-			if (theta === 0)
-				return false;
-
-			// Plane and line are not parallel. The intersection point can be calculated now.
-			const t = (this .distanceFromOrigin - this .normal .dot (point)) / theta;
-
-			intersection .x = point .x + direction .x * t;
-			intersection .y = point .y + direction .y * t;
-			intersection .z = point .z + direction .z * t;
-
-			return true;
-		},
-		toString: function ()
-		{
-			return this .normal .toString () + " " + this .distanceFromOrigin;
-		},
-	};
-
-	return Plane3;
+   const
+      normal    = new Vector3 (0, 0, 0),
+      point     = new Vector3 (0, 0, 0),
+      invMatrix = new Matrix4 ();
+
+   function Plane3 (point, normal)
+   {
+      this .normal             = normal .copy ();
+      this .distanceFromOrigin = normal .dot (point);
+   }
+
+   Plane3 .prototype =
+   {
+      constructor: Plane3,
+      copy: function ()
+      {
+         const copy = Object .create (Plane3 .prototype);
+         copy .normal             = this .normal .copy ();
+         copy .distanceFromOrigin = this .distanceFromOrigin;
+         return copy;
+      },
+      assign: function (plane)
+      {
+         this .normal .assign (plane .normal);
+         this .distanceFromOrigin = plane .distanceFromOrigin;
+         return this;
+      },
+      set: function (point, normal)
+      {
+         this .normal .assign (normal);
+         this .distanceFromOrigin = normal .dot (point);
+         return this;
+      },
+      multRight: function (matrix)
+      //throw
+      {
+         // Taken from Inventor:
+
+         // Find the point on the plane along the normal from the origin
+         point .assign (this .normal) .multiply (this .distanceFromOrigin);
+
+         // Transform the plane normal by the matrix
+         // to get the new normal. Use the inverse transpose
+         // of the matrix so that normals are not scaled incorrectly.
+         // n' = n * !~m = ~m * n
+         invMatrix .assign (matrix) .inverse ();
+         invMatrix .multMatrixDir (normal .assign (this .normal)) .normalize ();
+
+         // Transform the point by the matrix
+         matrix .multVecMatrix (point);
+
+         // The new distance is the projected distance of the vector to the
+         // transformed point onto the (unit) transformed normal. This is
+         // just a dot product.
+         this .normal .assign (normal);
+         this .distanceFromOrigin = normal .dot (point);
+
+         return this;
+      },
+      multLeft: function (matrix)
+      //throw
+      {
+         // Taken from Inventor:
+
+         // Find the point on the plane along the normal from the origin
+         point .assign (this .normal) .multiply (this .distanceFromOrigin);
+
+         // Transform the plane normal by the matrix
+         // to get the new normal. Use the inverse transpose
+         // of the matrix so that normals are not scaled incorrectly.
+         // n' = !~m * n = n * ~m
+         invMatrix .assign (matrix) .inverse ();
+         invMatrix .multDirMatrix (normal .assign (this .normal)) .normalize ();
+
+         // Transform the point by the matrix
+         matrix .multMatrixVec (point);
+
+         // The new distance is the projected distance of the vector to the
+         // transformed point onto the (unit) transformed normal. This is
+         // just a dot product.
+         this .normal .assign (normal);
+         this .distanceFromOrigin = normal .dot (point);
+
+         return this;
+      },
+      getDistanceToPoint: function (point)
+      {
+         return Vector3 .dot (point, this .normal) - this .distanceFromOrigin;
+      },
+      intersectsLine: function (line, intersection)
+      {
+         const
+            point     = line .point,
+            direction = line .direction;
+
+         // Check if the line is parallel to the plane.
+         const theta = direction .dot (this .normal);
+
+         // Plane and line are parallel.
+         if (theta === 0)
+            return false;
+
+         // Plane and line are not parallel. The intersection point can be calculated now.
+         const t = (this .distanceFromOrigin - this .normal .dot (point)) / theta;
+
+         intersection .x = point .x + direction .x * t;
+         intersection .y = point .y + direction .y * t;
+         intersection .z = point .z + direction .z * t;
+
+         return true;
+      },
+      toString: function ()
+      {
+         return this .normal .toString () + " " + this .distanceFromOrigin;
+      },
+   };
+
+   return Plane3;
 });