x_ite 5.0.3 → 6.1.0

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

@@ -120,7 +120,7 @@ function (Vector3)
                d1 = this .direction,
                d2 = line .direction;
 
-            let t = Vector3 .dot (d1, d2);
+            let t = d1 .dot (d2);
 
             if (Math .abs (t) >= 1)
                return false;  // lines are parallel
@@ -139,11 +139,9 @@ function (Vector3)
 
          return function (point, result)
          {
-            const d = result;
+            result .assign (this .point) .subtract (point);
 
-            d .assign (this .point) .subtract (point);
-
-            return d .subtract (t .assign (this .direction) .multiply (d .dot (this .direction)));
+            return result .subtract (t .assign (this .direction) .multiply (result .dot (this .direction)));
          };
       })(),
       getPerpendicularVectorToLine: (function ()

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

@@ -90,7 +90,6 @@ function (Vector3,
          return this;
       },
       multRight: function (matrix)
-      //throw
       {
          // Taken from Inventor:
 
@@ -116,7 +115,6 @@ function (Vector3,
          return this;
       },
       multLeft: function (matrix)
-      //throw
       {
          // Taken from Inventor:
 

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

@@ -66,7 +66,7 @@ function (Vector3,
 
          return function (a, b, c)
          {
-            return B .assign (b) .subtract (a) .cross (C .assign (c) .subtract (a)) .abs () / 2;
+            return B .assign (b) .subtract (a) .cross (C .assign (c) .subtract (a)) .magnitude () / 2;
          };
       })(),
       normal: function (v1, v2, v3, normal)

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

@@ -50,6 +50,7 @@
 define ([
    "standard/Math/Geometry/Plane3",
    "standard/Math/Geometry/Triangle3",
+   "standard/Math/Numbers/Vector2",
    "standard/Math/Numbers/Vector3",
    "standard/Math/Numbers/Vector4",
    "standard/Math/Numbers/Matrix4",
@@ -57,6 +58,7 @@ define ([
 ],
 function (Plane3,
           Triangle3,
+          Vector2,
           Vector3,
           Vector4,
           Matrix4,
@@ -136,66 +138,57 @@ function (Plane3,
 
          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);
-            }
+            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;
 
             return this;
          };
@@ -237,28 +230,25 @@ function (Plane3,
       },
       intersectsSphere: function (radius, center)
       {
-         if (this .valid)
-         {
-            const planes = this .planes;
+         const planes = this .planes;
 
-            if (planes [0] .getDistanceToPoint (center) > radius)
-               return false;
+         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;
       },
@@ -337,20 +327,18 @@ function (Plane3,
    {
       unProjectPoint: (function ()
       {
-         const matrix = new Matrix4 ();
+         const invModelViewProjectionMatrix = new Matrix4 ();
 
          return function (winx, winy, winz, modelViewMatrix, projectionMatrix, viewport, point)
          {
-            matrix .assign (modelViewMatrix) .multRight (projectionMatrix) .inverse ();
-
-            return this .unProjectPointMatrix (winx, winy, winz, matrix, viewport, point);
+            return this .unProjectPointMatrix (winx, winy, winz, invModelViewProjectionMatrix .assign (modelViewMatrix) .multRight (projectionMatrix) .inverse (), viewport, point);
          };
       })(),
       unProjectPointMatrix: (function ()
       {
          const vin = new Vector4 (0, 0, 0, 0);
 
-         return function (winx, winy, winz, invModelViewProjection, viewport, point)
+         return function (winx, winy, winz, invModelViewProjectionMatrix, viewport, point)
          {
             // Transformation of normalized coordinates between -1 and 1
             vin .set ((winx - viewport [0]) / viewport [2] * 2 - 1,
@@ -359,29 +347,32 @@ function (Plane3,
                       1);
 
             //Objects coordinates
-            invModelViewProjection .multVecMatrix (vin);
-
-            if (vin .w === 0)
-               throw new Error ("Couldn't unproject point: divisor is 0.");
+            invModelViewProjectionMatrix .multVecMatrix (vin);
 
             const d = 1 / vin .w;
 
-            return point .set (vin .x * d, vin .y * d, vin .z * d);
+            return point .set (vin .x * d, vin .y * d, vin .z * d, 1);
          };
       })(),
       unProjectRay: (function ()
       {
-         const
-            near   = new Vector3 (0, 0, 0),
-            far    = new Vector3 (0, 0, 0),
-            matrix = new Matrix4 ();
+         const invModelViewProjectionMatrix = new Matrix4 ();
 
          return function (winx, winy, modelViewMatrix, projectionMatrix, viewport, result)
          {
-            matrix .assign (modelViewMatrix) .multRight (projectionMatrix) .inverse ();
+            return this .unProjectRayMatrix (winx, winy, invModelViewProjectionMatrix .assign (modelViewMatrix) .multRight (projectionMatrix) .inverse (), viewport, result);
+         };
+      })(),
+      unProjectRayMatrix: (function ()
+      {
+         const
+            near = new Vector3 (0, 0, 0),
+            far  = new Vector3 (0, 0, 0);
 
-            ViewVolume .unProjectPointMatrix (winx, winy, 0.0, matrix, viewport, near);
-            ViewVolume .unProjectPointMatrix (winx, winy, 0.9, matrix, viewport, far);
+         return function (winx, winy, invModelViewProjectionMatrix, viewport, result)
+         {
+            ViewVolume .unProjectPointMatrix (winx, winy, 0.0, invModelViewProjectionMatrix, viewport, near);
+            ViewVolume .unProjectPointMatrix (winx, winy, 0.9, invModelViewProjectionMatrix, viewport, far);
 
             return result .setPoints (near, far);
          };
@@ -392,12 +383,32 @@ function (Plane3,
 
          return function (point, modelViewMatrix, projectionMatrix, viewport, vout)
          {
-            vin .set (point .x, point .y, point .z, 1);
+            if (point .length === 4)
+               vin .assign (point);
+            else
+               vin .set (point .x, point .y, point .z, 1);
 
             projectionMatrix .multVecMatrix (modelViewMatrix .multVecMatrix (vin));
 
-            if (vin .w === 0)
-               throw new Error ("Couldn't project point: divisor is 0.");
+            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));
+         };
+      })(),
+      projectPointMatrix: (function ()
+      {
+         const vin = new Vector4 (0, 0, 0, 0);
+
+         return function (point, modelViewProjectionMatrix, viewport, vout)
+         {
+            if (point .length === 4)
+               vin .assign (point);
+            else
+               vin .set (point .x, point .y, point .z, 1);
+
+            modelViewProjectionMatrix .multVecMatrix (vin);
 
             const d = 1 / (2 * vin .w);
 
@@ -408,17 +419,24 @@ function (Plane3,
       })(),
       projectLine: (function ()
       {
-         const
-            near = new Vector3 (0, 0, 0),
-            far  = new Vector3 (0, 0, 0);
+         const modelViewProjectionMatrix = new Matrix4 ();
 
          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 this .projectLineMatrix (line, modelViewProjectionMatrix .assign (modelViewMatrix) .multRight (projectionMatrix), viewport, result);
+         };
+      })(),
+      projectLineMatrix: (function ()
+      {
+         const
+            near      = new Vector2 (0, 0),
+            far       = new Vector2 (0, 0),
+            direction = new Vector3 (0, 0, 0);
 
-            near .z = 0;
-            far  .z = 0;
+         return function (line, modelViewProjectionMatrix, viewport, result)
+         {
+            ViewVolume .projectPointMatrix (line .point, modelViewProjectionMatrix, viewport, near);
+            ViewVolume .projectPointMatrix (direction .assign (line .direction) .multiply (1e9) .add (line .point), modelViewProjectionMatrix, viewport, far);
 
             return result .setPoints (near, far);
          };

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

@@ -81,6 +81,12 @@ function (Algorithm)
    {
       constructor: Color3,
       length: 3,
+      [Symbol .iterator]: function* ()
+      {
+         yield this [_r];
+         yield this [_g];
+         yield this [_b];
+      },
       copy: function ()
       {
          const copy = Object .create (Color3 .prototype);

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

@@ -85,6 +85,13 @@ function (Color3, Algorithm)
    {
       constructor: Color4,
       length: 4,
+      [Symbol .iterator]: function* ()
+      {
+         yield this [_r];
+         yield this [_g];
+         yield this [_b];
+         yield this [_a];
+      },
       copy: function ()
       {
          const copy = Object .create (Color4 .prototype);

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

@@ -53,13 +53,18 @@ define (function ()
 
    function Complex (real, imag)
    {
-      this .real = real
+      this .real = real;
       this .imag = imag;
    }
 
    Complex .prototype =
    {
       constructor: Complex,
+      [Symbol .iterator]: function* ()
+      {
+         yield this .real;
+         yield this .imag;
+      },
       copy: function ()
       {
          const copy = Object .create (Complex .prototype);
@@ -78,34 +83,10 @@ define (function ()
          return this .real === complex .real &&
                 this .imag === complex .imag;
       },
-      setRadius: function (radius)
-      {
-         return this .setPolar (radius, this .getAngle ());
-      },
-      getRadius: function ()
-      {
-         if (this .real)
-         {
-            if (this .imag)
-               return Math .hypot (this .real, this .imag);
-
-            return Math .abs (this .real);
-         }
-
-         return Math .abs (this .imag);
-      },
-      setAngle: function (angle)
-      {
-         return this .setPolar (this .getRadius (), angle);
-      },
-      getAngle: function ()
+      setPolar: function (magnitude, angle)
       {
-         return Math .atan2 (this .imag, this .real);
-      },
-      setPolar: function (radius, angle)
-      {
-         this .real = radius * Math .cos (angle);
-         this .imag = radius * Math .sin (angle);
+         this .real = magnitude * Math .cos (angle);
+         this .imag = magnitude * Math .sin (angle);
          return this;
       },
       conjugate: function ()
@@ -176,18 +157,51 @@ define (function ()
          if (this .imag)
             return this .real + " " + this .imag + "i";
 
-         return "" + this .real;
+         return String (this .real);
       },
    };
 
+   Object .defineProperty (Complex .prototype, "magnitude",
+   {
+      get: function ()
+      {
+         if (this .real)
+         {
+            if (this .imag)
+               return Math .hypot (this .real, this .imag);
+
+            return Math .abs (this .real);
+         }
+
+         return Math .abs (this .imag);
+      },
+      set: function (magnitude)
+      {
+         this .setPolar (magnitude, this .angle);
+      },
+      enumerable: false,
+      configurable: false
+   });
+
+   Object .defineProperty (Complex .prototype, "angle",
+   {
+      get: function ()
+      {
+         return Math .atan2 (this .imag, this .real);
+      },
+      set: function (angle)
+      {
+         this .setPolar (this .magnitude, angle);
+      },
+      enumerable: false,
+      configurable: false
+   });
+
    Object .assign (Complex,
    {
-      Polar: function (radius, angle)
+      Polar: function (magnitude, angle)
       {
-         const complex = Object .create (Complex .prototype);
-         complex .real = radius * Math .cos (angle);
-         complex .imag = radius * Math .sin (angle);
-         return complex;
+         return Object .create (Complex .prototype) .setPolar (magnitude, angle);
       },
       multiply: function (lhs, rhs)
       {

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

@@ -76,6 +76,13 @@ function (Vector2,
       constructor: Matrix2,
       order: 2,
       length: 4,
+      [Symbol .iterator]: function* ()
+      {
+         const length = this .length;
+
+         for (let i = 0; i < length; ++ i)
+            yield this [i];
+      },
       copy: function ()
       {
          const copy = Object .create (Matrix2 .prototype);
@@ -126,6 +133,8 @@ function (Vector2,
                break;
             }
          }
+
+         return this;
       },
       determinant1: function ()
       {
@@ -154,8 +163,7 @@ function (Vector2,
             D = this [3],
             d = A * D - B * C;
 
-         if (d === 0)
-            throw new Error ("Matrix2 .inverse: determinant is 0.");
+         // if (d === 0) ... determinant is zero.
 
          this [0] =  D / d;
          this [1] = -B / d;
@@ -194,6 +202,46 @@ function (Vector2,
 
          return this;
       },
+      multVecMatrix: function (vector)
+      {
+         if (typeof vector === "number")
+         {
+            const
+               x = vector,
+               w = x * this [2] + this [3];
+
+            return (x * this [0] + this [1]) / w;
+         }
+
+         const
+            x = vector .x,
+            y = vector .y;
+
+         vector .x = x * this [0] + y * this [2];
+         vector .y = x * this [1] + y * this [3];
+
+         return vector;
+      },
+      multMatrixVec: function (vector)
+      {
+         if (typeof vector === "number")
+         {
+            const
+               x = vector,
+               w = x * this [2] + this [3];
+
+            return (x * this [0] + this [1]) / w;
+         }
+
+         const
+            x = vector .x,
+            y = vector .y;
+
+         vector .x = x * this [0] + y * this [1];
+         vector .y = x * this [2] + y * this [3];
+
+         return vector;
+      },
       identity: function ()
       {
          this [0] = 1;
@@ -220,6 +268,18 @@ function (Vector2,
       configurable: false
    });
 
+   Object .defineProperty (Matrix2 .prototype, "y",
+   {
+      get: (function ()
+      {
+         const vector = new Vector2 (0, 0);
+
+         return function () { return vector .set (this [2], this [3]); };
+      })(),
+      enumerable: false,
+      configurable: false
+   });
+
    Object .defineProperty (Matrix2 .prototype, "xAxis",
    {
       get: function () { return this [0]; },