x_ite 5.0.3 → 6.1.0

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

@@ -67,6 +67,13 @@ function (Vector3, Algorithm)
    {
       constructor: Quaternion,
       length: 4,
+      [Symbol .iterator]: function* ()
+      {
+         yield this .x;
+         yield this .y;
+         yield this .z;
+         yield this .w;
+      },
       copy: function ()
       {
          const copy = Object .create (Quaternion .prototype);
@@ -318,7 +325,7 @@ function (Vector3, Algorithm)
                 this .z * this .z +
                 this .w * this .w;
       },
-      abs: function ()
+      magnitude: function ()
       {
          return Math .hypot (this .x, this .y, this .z, this .w);
       },
@@ -331,9 +338,9 @@ function (Vector3, Algorithm)
             return this .set (0, 0, 0, Math .pow (this .w, exponent));
 
          const
-            l     = this .abs (),
+            l     = this .magnitude (),
             theta = Math .acos (this .w / l),
-            li    = this .imag .abs (),
+            li    = this .imag .magnitude (),
             ltoe  = Math .pow (l, exponent),
             et    = exponent * theta,
             scale = ltoe / li * Math .sin (et);
@@ -356,7 +363,7 @@ function (Vector3, Algorithm)
          }
 
          const
-            l = this .abs (),
+            l = this .magnitude (),
             v = this .imag .normalize () .multiply (Math .acos (this .w / l)),
             w = Math .log (l);
 
@@ -373,7 +380,7 @@ function (Vector3, Algorithm)
 
          const
             i  = this .imag,
-            li = i .abs (),
+            li = i .magnitude (),
             ew = Math .exp (this .w),
             w  = ew * Math .cos (li),
             v  = i .multiply (ew * Math .sin (li) / li);

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

@@ -117,6 +117,13 @@ function (Quaternion,
    {
       constructor: Rotation4,
       length: 4,
+      [Symbol .iterator]: function* ()
+      {
+         yield this [_x];
+         yield this [_y];
+         yield this [_z];
+         yield this [_angle];
+      },
       update: function ()
       {
          const rotation = this .get ();
@@ -235,7 +242,7 @@ function (Quaternion,
             const
                cos_angle = Algorithm .clamp (from .dot (to), -1, 1),
                crossvec  = cv .assign (from) .cross (to) .normalize (),
-               crosslen  = crossvec .abs ();
+               crosslen  = crossvec .magnitude ();
 
             if (crosslen === 0)
             {

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

@@ -64,6 +64,11 @@ function (Algorithm)
    {
       constructor: Vector2,
       length: 2,
+      [Symbol .iterator]: function* ()
+      {
+         yield this .x;
+         yield this .y;
+      },
       copy: function ()
       {
          const copy = Object .create (Vector2 .prototype);
@@ -94,6 +99,12 @@ function (Algorithm)
          this .y = -this .y;
          return this;
       },
+      inverse: function ()
+      {
+         this .x = 1 / this .x;
+         this .y = 1 / this .y;
+         return this;
+      },
       add: function (vector)
       {
          this .x += vector .x;
@@ -132,14 +143,12 @@ function (Algorithm)
       },
       normalize: function ()
       {
-         let length = Math .hypot (this .x, this .y);
+         const length = Math .hypot (this .x, this .y);
 
          if (length)
          {
-            length = 1 / length;
-
-            this .x *= length;
-            this .y *= length;
+            this .x /= length;
+            this .y /= length;
          }
 
          return this;
@@ -158,7 +167,7 @@ function (Algorithm)
          return x * x +
                 y * y;
       },
-      abs: function ()
+      magnitude: function ()
       {
          return Math .hypot (this .x, this .y);
       },
@@ -177,6 +186,12 @@ function (Algorithm)
          this .y = y + t * (destination .y - y);
          return this;
       },
+      abs: function ()
+      {
+         this .x = Math .abs (this .x);
+         this .y = Math .abs (this .y);
+         return this;
+      },
       min: function (vector)
       {
          let
@@ -236,10 +251,16 @@ function (Algorithm)
    {
       Zero: new Vector2 (0, 0),
       One: new Vector2 (1, 1),
+      xAxis: new Vector2 (1, 0),
+      yAxis: new Vector2 (0, 1),
       negate: function (vector)
       {
          return vector .copy () .negate ();
       },
+      inverse: function (vector)
+      {
+         return vector .copy () .inverse ();
+      },
       add: function (lhs, rhs)
       {
          return lhs .copy () .add (rhs);
@@ -270,19 +291,31 @@ function (Algorithm)
       },
       dot: function (lhs, rhs)
       {
-         return lhs .copy () .dot (rhs);
+         return lhs .dot (rhs);
+      },
+      magnitude: function (vector)
+      {
+         return vector .magnitude ();
+      },
+      distance: function (lhs, rhs)
+      {
+         return lhs .distance (rhs);
       },
       lerp: function (source, destination, t)
       {
          return source .copy () .lerp (destination, t);
       },
+      abs: function (vector)
+      {
+         return vector .copy () .abs ();
+      },
       min: function (lhs, rhs)
       {
-         return Vector2 .prototype .min .apply (lhs .copy (), arguments);
+         return this .prototype .min .apply (lhs .copy (), arguments);
       },
       max: function (lhs, rhs)
       {
-         return Vector2 .prototype .max .apply (lhs .copy (), arguments);
+         return this .prototype .max .apply (lhs .copy (), arguments);
       },
    });
 

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

@@ -65,6 +65,12 @@ function (Algorithm)
    {
       constructor: Vector3,
       length: 3,
+      [Symbol .iterator]: function* ()
+      {
+         yield this .x;
+         yield this .y;
+         yield this .z;
+      },
       copy: function ()
       {
          const copy = Object .create (Vector3 .prototype);
@@ -100,6 +106,13 @@ function (Algorithm)
          this .z = -this .z;
          return this;
       },
+      inverse: function ()
+      {
+         this .x = 1 / this .x;
+         this .y = 1 / this .y;
+         this .z = 1 / this .z;
+         return this;
+      },
       add: function (vector)
       {
          this .x += vector .x;
@@ -144,25 +157,25 @@ function (Algorithm)
       },
       cross: function (vector)
       {
-         const x = this .x, y = this .y, z = this .z;
+         const
+            ax = this   .x, ay = this   .y, az = this   .z,
+            bx = vector .x, by = vector .y, bz = vector .z;
 
-         this .x = y * vector .z - z * vector .y;
-         this .y = z * vector .x - x * vector .z;
-         this .z = x * vector .y - y * vector .x;
+         this .x = ay * bz - az * by;
+         this .y = az * bx - ax * bz;
+         this .z = ax * by - ay * bx;
 
          return this;
       },
       normalize: function ()
       {
-         let length = Math .hypot (this .x, this .y, this .z);
+         const length = Math .hypot (this .x, this .y, this .z);
 
          if (length)
          {
-            length = 1 / length;
-
-            this .x *= length;
-            this .y *= length;
-            this .z *= length;
+            this .x /= length;
+            this .y /= length;
+            this .z /= length;
          }
 
          return this;
@@ -184,7 +197,7 @@ function (Algorithm)
                 y * y +
                 z * z;
       },
-      abs: function ()
+      magnitude: function ()
       {
          return Math .hypot (this .x, this .y, this .z);
       },
@@ -215,6 +228,13 @@ function (Algorithm)
             return Algorithm .simpleSlerp (this, tmp .assign (destination), t);
          };
       })(),
+      abs: function ()
+      {
+         this .x = Math .abs (this .x);
+         this .y = Math .abs (this .y);
+         this .z = Math .abs (this .z);
+         return this;
+      },
       min: function (vector)
       {
          let
@@ -296,6 +316,10 @@ function (Algorithm)
       {
          return vector .copy () .negate ();
       },
+      inverse: function (vector)
+      {
+         return vector .copy () .inverse ();
+      },
       add: function (lhs, rhs)
       {
          return lhs .copy () .add (rhs);
@@ -330,7 +354,15 @@ function (Algorithm)
       },
       dot: function (lhs, rhs)
       {
-         return lhs .copy () .dot (rhs);
+         return lhs .dot (rhs);
+      },
+      magnitude: function (vector)
+      {
+         return vector .magnitude ();
+      },
+      distance: function (lhs, rhs)
+      {
+         return lhs .distance (rhs);
       },
       lerp: function (source, destination, t)
       {
@@ -340,13 +372,17 @@ function (Algorithm)
       {
          return source .copy () .slerp (destination, t);
       },
+      abs: function (vector)
+      {
+         return vector .copy () .abs ();
+      },
       min: function (lhs, rhs)
       {
-         return Vector3 .prototype .min .apply (lhs .copy (), arguments);
+         return this .prototype .min .apply (lhs .copy (), arguments);
       },
       max: function (lhs, rhs)
       {
-         return Vector3 .prototype .max .apply (lhs .copy (), arguments);
+         return this .prototype .max .apply (lhs .copy (), arguments);
       },
    });
 

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

@@ -66,6 +66,13 @@ function (Algorithm)
    {
       constructor: Vector4,
       length: 4,
+      [Symbol .iterator]: function* ()
+      {
+         yield this .x;
+         yield this .y;
+         yield this .z;
+         yield this .w;
+      },
       copy: function ()
       {
          const copy = Object .create (Vector4 .prototype);
@@ -112,6 +119,14 @@ function (Algorithm)
          this .w = -this .w;
          return this;
       },
+      inverse: function ()
+      {
+         this .x = 1 / this .x;
+         this .y = 1 / this .y;
+         this .z = 1 / this .z;
+         this .w = 1 / this .w;
+         return this;
+      },
       add: function (vector)
       {
          this .x += vector .x;
@@ -162,16 +177,14 @@ function (Algorithm)
       },
       normalize: function ()
       {
-         let length = Math .hypot (this .x, this .y, this .z, this .w);
+         const length = Math .hypot (this .x, this .y, this .z, this .w);
 
          if (length)
          {
-            length = 1 / length;
-
-            this .x *= length;
-            this .y *= length;
-            this .z *= length;
-            this .w *= length;
+            this .x /= length;
+            this .y /= length;
+            this .z /= length;
+            this .w /= length;
          }
 
          return this;
@@ -196,7 +209,7 @@ function (Algorithm)
                 z * z +
                 w * w;
       },
-      abs: function ()
+      magnitude: function ()
       {
          return Math .hypot (this .x, this .y, this .z, this .w);
       },
@@ -221,6 +234,14 @@ function (Algorithm)
          this .w = w + t * (destination .w - w);
          return this;
       },
+      abs: function ()
+      {
+         this .x = Math .abs (this .x);
+         this .y = Math .abs (this .y);
+         this .z = Math .abs (this .z);
+         this .w = Math .abs (this .w);
+         return this;
+      },
       min: function (vector)
       {
          let
@@ -318,6 +339,10 @@ function (Algorithm)
       {
          return vector .copy () .negate ();
       },
+      inverse: function (vector)
+      {
+         return vector .copy () .inverse ();
+      },
       add: function (lhs, rhs)
       {
          return lhs .copy () .add (rhs);
@@ -348,19 +373,31 @@ function (Algorithm)
       },
       dot: function (lhs, rhs)
       {
-         return lhs .copy () .dot (rhs);
+         return lhs .dot (rhs);
+      },
+      magnitude: function (vector)
+      {
+         return vector .magnitude ();
+      },
+      distance: function (lhs, rhs)
+      {
+         return lhs .distance (rhs);
       },
       lerp: function (source, destination, t)
       {
          return source .copy () .lerp (destination, t);
       },
+      abs: function (vector)
+      {
+         return vector .copy () .abs ();
+      },
       min: function (lhs, rhs)
       {
-         return Vector4 .prototype .min .apply (lhs .copy (), arguments);
+         return this .prototype .min .apply (lhs .copy (), arguments);
       },
       max: function (lhs, rhs)
       {
-         return Vector4 .prototype .max .apply (lhs .copy (), arguments);
+         return this .prototype .max .apply (lhs .copy (), arguments);
       },
    });
 

package/src/standard/Math/Utility/BVH.js

@@ -74,28 +74,24 @@ function (Vector3,
       // left: We do not have to test for left.
    ];
 
+   const
+      NODE     = 0,
+      TRIANGLE = 1;
+
    function SortComparator (vertices, axis)
    {
-      function compare (a, b)
+      return function compare (a, b)
       {
-         const
-            vertices = compare .vertices;
-            axis     = compare .axis;
-
-         return Math .min (vertices [a + axis], vertices [a + 4 + axis], vertices [a + 8 + axis]) <
-                Math .min (vertices [b + axis], vertices [b + 4 + axis], vertices [b + 8 + axis]);
+          return Math .min (vertices [a + axis], vertices [a + 4 + axis], vertices [a + 8 + axis]) <
+                 Math .min (vertices [b + axis], vertices [b + 4 + axis], vertices [b + 8 + axis]);
       }
-
-      compare .vertices = vertices;
-      compare .axis     = axis;
-
-      return compare;
    }
 
    function Triangle (tree, triangle)
    {
       this .vertices = tree .vertices;
       this .normals  = tree .normals;
+      this .triangle = triangle;
       this .i4       = triangle * 12;
       this .i3       = triangle * 9;
    }
@@ -145,6 +141,14 @@ function (Vector3,
             }
          }
       },
+      toArray: function (array)
+      {
+         const index = array .length / 4;
+
+         array .push (TRIANGLE, this .triangle * 3, 0, 0);
+
+         return index;
+      },
    };
 
    function Node (tree, triangles, first, size)
@@ -303,15 +307,30 @@ function (Vector3,
             return 0;
          }
       },
+      toArray: function (array)
+      {
+         const
+            left  = this .left .toArray (array),
+            right = this .right .toArray (array),
+            min   = this .min,
+            max   = this .max,
+            index = array .length / 4;
+
+         array .push (NODE, left, right, 0,
+                      min .x, min .y, min .z, 0,
+                      max .x, max .y, max .z, 0);
+
+         return index;
+      },
    };
 
    function BVH (vertices, normals)
    {
+      const numTriangles = vertices .length / 12;
+
       this .vertices = vertices;
       this .normals  = normals;
 
-      const numTriangles = vertices .length / 12;
-
       switch (numTriangles)
       {
          case 0:
@@ -332,8 +351,7 @@ function (Vector3,
                triangles .push (i);
 
             this .sorter = new QuickSort (triangles, SortComparator (vertices, 0));
-
-            this .root = new Node (this, triangles, 0, numTriangles);
+            this .root   = new Node (this, triangles, 0, numTriangles);
             break;
          }
       }
@@ -342,7 +360,6 @@ function (Vector3,
    BVH .prototype =
    {
       constructor: BVH,
-
       intersectsLine: function (line, intersections, intersectionNormals)
       {
          intersections .size = 0;
@@ -355,6 +372,17 @@ function (Vector3,
 
          return 0;
       },
+      toArray: function (array)
+      {
+         if (this .root)
+         {
+            const root = this .root .toArray (array);
+
+            array .push (root, 0, 0, 0);
+         }
+
+         return array;
+      },
    };
 
    return BVH;