x_ite 8.4.3 → 8.5.3

package/src/lib/libtess.js

@@ -0,0 +1 @@
+export default libtess;

package/src/lib/nurbs/extras/sample.js

@@ -188,13 +188,13 @@ export default function (mesh, surface, opts)
             }
 
             var
-               curves    = [ ],
+               contours  = [ ],
                triangles = [ ],
                trimmed   = [ ];
 
             for (var v = 0, fLength = faces .length; v < fLength; v += 3)
             {
-               curves    .length = 0;
+               contours  .length = 0;
                triangles .length = 0;
 
                var
@@ -211,11 +211,9 @@ export default function (mesh, surface, opts)
                vertex2 .index = v + 1;
                vertex3 .index = v + 2;
 
-               curves .push ([ vertex1, vertex2, vertex3 ]);
-               curves .push .apply (curves, holes);
-               curves .push (triangles);
+               contours .push ([ vertex1, vertex2, vertex3 ], ... holes);
 
-               Triangle3 .triangulatePolygon .apply (Triangle3, curves);
+               Triangle3 .triangulatePolygon (contours, triangles);
 
                for (var t = 0, tLength = triangles .length; t < tLength; ++ t)
                   trimmed .push (triangles [t] .index);
@@ -228,7 +226,7 @@ export default function (mesh, surface, opts)
          break;
       }
       default:
-         throw new Error("Can only sample curves and surfaces");
+         throw new Error("Can only sample contours and surfaces");
    }
 
    return mesh;

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

@@ -46,61 +46,203 @@
  ******************************************************************************/
 
 import Algorithm from "../Algorithm.js";
+import Vector2   from "../Numbers/Vector2.js";
 
 const lerp = Algorithm .lerp;
 
-function Bezier (x0, y0, x1, y1, x2, y2, x3, y3)
+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;
+   this .args = arguments;
 }
 
 Bezier .prototype =
 {
-   getLUT: function (dimension)
+   getPoints: function (type, steps)
    {
-      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)
+      const points = [ ];
+
+      switch (type)
       {
-         case 2:
+         case "quadric":
+         {
+            const
+               x0 = this .args [0],
+               y0 = this .args [1],
+               x1 = this .args [2],
+               y1 = this .args [3],
+               x2 = this .args [4],
+               y2 = this .args [5];
+
+            for (let i = 0, d = steps - 1; i < steps; ++ i)
+            {
+               points .push (quadric (x0, y0, x1, y1, x2, y2, i / d));
+            }
+
+            break;
+         }
+         case "cubic":
          {
-            for (let i = 0, d = dimension - 1; i < dimension; ++ i)
+            const
+               x0 = this .args [0],
+               y0 = this .args [1],
+               x1 = this .args [2],
+               y1 = this .args [3],
+               x2 = this .args [4],
+               y2 = this .args [5],
+               x3 = this .args [6],
+               y3 = this .args [7];
+
+            for (let i = 0, d = steps - 1; i < steps; ++ i)
             {
-               lut .push (quadric (x0, y0, x1, y1, x2, y2, i / d));
+               points .push (cubic (x0, y0, x1, y1, x2, y2, x3, y3, i / d));
             }
 
             break;
          }
-         case 3:
+         case "arc":
          {
-            for (let i = 0, d = dimension - 1; i < dimension; ++ i)
+            let
+               ax            = this .args [0],
+               ay            = this .args [1],
+               rx            = this .args [2],
+               ry            = this .args [3],
+               xAxisRotation = this .args [4],
+               largeArcFlag  = this .args [5],
+               sweepFlag     = this .args [6],
+               x             = this .args [7],
+               y             = this .args [8];
+
+            // https://ericeastwood.com/blog/25/curves-and-arcs-quadratic-cubic-elliptical-svg-implementations
+            // See https://www.w3.org/TR/SVG/implnote.html#ArcImplementationNotes.
+
+            // If the endpoints are identical, then this is equivalent to omitting the elliptical arc segment entirely.
+            if (ax === x && ay === y)
             {
-               lut .push (cubic (x0, y0, x1, y1, x2, y2, x3, y3, i / d));
+               points .push (new Vector2 (x, y));
+               return;
+            }
+
+            // In accordance to: http://www.w3.org/TR/SVG/implnote.html#ArcOutOfRangeParameters
+
+            rx = Math .abs (rx);
+            ry = Math .abs (ry);
+
+            // If rx = 0 or ry = 0 then this arc is treated as a straight line segment joining the endpoints.
+            if (rx === 0 || ry === 0)
+            {
+               points .push (new Vector2 (ax, ay), new Vector2 (x, y));
+               return;
+            }
+
+            const
+               rx2 = rx * rx,
+               ry2 = ry * ry;
+
+            // In accordance to: http://www.w3.org/TR/SVG/implnote.html#ArcOutOfRangeParameters
+
+            xAxisRotation = Algorithm .interval (xAxisRotation, 0, 2 * Math .PI);
+
+            const
+               sinRotation = Math .sin (xAxisRotation),
+               cosRotation = Math .cos (xAxisRotation);
+
+            // Following "Conversion from endpoint to center parameterization"
+            // http://www.w3.org/TR/SVG/implnote.html#ArcConversionEndpointToCenter
+
+            // Step #1: Compute transformedPoint
+            const d = new Vector2 (ax - x, ay - y) .divide (2);
+
+            const transformedPoint = new Vector2 ( cosRotation * d .x + sinRotation * d .y,
+                                                  -sinRotation * d .x + cosRotation * d .y);
+
+            const transformedPoint2 = transformedPoint .copy () .multVec (transformedPoint);
+
+            // Ensure radii are large enough
+            const radiiCheck = transformedPoint2 .x / rx2 + transformedPoint2 .y / ry2;
+
+            if (radiiCheck > 1)
+            {
+               rx = Math .sqrt (radiiCheck) * rx;
+               ry = Math .sqrt (radiiCheck) * ry;
+            }
+
+            // Step #2: Compute transformedCenter
+            const cSquareNumerator = rx2 * ry2 - rx2 * transformedPoint2 .y - ry2 * transformedPoint2 .x;
+            const cSquareRootDenom =             rx2 * transformedPoint2 .y + ry2 * transformedPoint2 .x;
+            let   cRadicand        = cSquareNumerator / cSquareRootDenom;
+
+            // Make sure this never drops below zero because of precision
+            cRadicand = Math .max (0, cRadicand);
+
+            const cCoef = (largeArcFlag !== sweepFlag ? 1 : -1) * Math .sqrt (cRadicand);
+
+            const transformedCenter = new Vector2 ( cCoef * rx * transformedPoint .y / ry,
+                                                   -cCoef * ry * transformedPoint .x / rx);
+
+            // Step #3: Compute center
+            const center = new Vector2 (cosRotation * transformedCenter .x - sinRotation * transformedCenter .y + ((ax + x) / 2),
+                                        sinRotation * transformedCenter .x + cosRotation * transformedCenter .y + ((ay + y) / 2));
+
+            // Step #4: Compute start/sweep angles
+            const startVector = new Vector2 ((transformedPoint .x - transformedCenter .x) / rx,
+                                             (transformedPoint .y - transformedCenter .y) / ry);
+
+            const endVector = new Vector2 ((-transformedPoint .x - transformedCenter .x) / rx,
+                                           (-transformedPoint .y - transformedCenter .y) / ry);
+
+            const get_angle  = (x) => { return x > 0 ? x : 2 * Math .PI + x; }; // transform angle to range [0, 2pi]
+            const startAngle = get_angle (Math .atan2 (startVector .y, startVector .x));
+            const endAngle   = get_angle (Math .atan2 (endVector   .y, endVector   .x));
+
+            let sweepAngle = endAngle - startAngle;
+
+            if (largeArcFlag)
+            {
+               // sweepAngle must be positive
+               if (sweepAngle < 0)
+                  sweepAngle += 2 * Math .PI;
+            }
+            else
+            {
+               // sweepAngle must be negative
+               if (sweepAngle > 0)
+                  sweepAngle -= 2 * Math .PI;
+            }
+
+            if (sweepFlag && sweepAngle < 0)
+               sweepAngle += 2 *Math .PI;
+
+            else if (!sweepFlag && sweepAngle > 0)
+               sweepAngle -= 2 * Math .PI;
+
+            // Interpolate:
+
+            const bezier_steps   = Math .max (4, Math .abs (sweepAngle) * steps / (2 * Math .PI));
+            const bezier_steps_1 = bezier_steps - 1;
+
+            points .push (new Vector2 (ax, ay));
+
+            for (let i = 1; i < bezier_steps_1; ++ i)
+            {
+               const t = i / bezier_steps_1;
+
+               // From http://www.w3.org/TR/SVG/implnote.html#ArcParameterizationAlternatives
+               const angle = startAngle + (sweepAngle * t);
+               const x     = rx * Math .cos (angle);
+               const y     = ry * Math .sin (angle);
+
+               const point = new Vector2 (cosRotation * x - sinRotation * y + center .x,
+                                          sinRotation * x + cosRotation * y + center .y);
+
+               points .push (point);
             }
 
+            points .push (new Vector2 (x, y));
             break;
          }
       }
 
-      return lut;
+      return points;
    }
 };
 
@@ -114,7 +256,7 @@ function quadric (x0, y0, x1, y1, x2, y2, t)
       bx0 = lerp (ax0, ax1, t),
       by0 = lerp (ay0, ay1, t);
 
-   return {x: bx0, y: by0};
+   return new Vector2 (bx0, by0);
 }
 
 function cubic (x0, y0, x1, y1, x2, y2, x3, y3, t)
@@ -133,7 +275,7 @@ function cubic (x0, y0, x1, y1, x2, y2, x3, y3, t)
       cx0 = lerp (bx0, bx1, t),
       cy0 = lerp (by0, by1, t);
 
-   return {x: cx0, y: cy0};
+   return new Vector2 (cx0, cy0);
 }
 
 export default Bezier;

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

@@ -50,38 +50,9 @@ import Vector2 from "../Numbers/Vector2.js";
 
 function Box2 (size, center)
 {
-   switch (arguments .length)
-   {
-      case 0:
-      {
-         this .matrix = new Matrix3 (0, 0, 0,
-                                     0, 0, 0,
-                                     0, 0, 0);
-         return;
-      }
-      case 2:
-      {
-         this .matrix = new Matrix3 (size .x / 2, 0, 0,
-                                     0, size .y / 2, 0,
-                                     center .x, center .y, 1);
-         return;
-      }
-      case 3:
-      {
-         const
-            min = arguments [0],
-            max = arguments [1],
-            sx  = (max .x - min .x) / 2,
-            sy  = (max .y - min .y) / 2,
-            cx  = (max .x + min .x) / 2,
-            cy  = (max .y + min .y) / 2;
+   this .matrix = new Matrix3 ();
 
-         this .matrix = new Matrix3 (sx, 0,  0,
-                                     0,  sy, 0,
-                                     cx, cy, 1);
-         return;
-      }
-   }
+   this .set (... arguments);
 }
 
 Box2 .prototype =
@@ -104,39 +75,27 @@ Box2 .prototype =
    },
    set: function (size, center)
    {
-      const m = this .matrix;
-
       switch (arguments .length)
       {
          case 0:
          {
-            m [0] = 0.5; m [1] = 0;   m [2] = 0;
-            m [3] = 0;   m [4] = 0.5; m [5] = 0;
-            m [6] = 0;   m [7] = 0;   m [8] = 0;
+            this .matrix .set (0, 0, 0,
+                               0, 0, 0,
+                               0, 0, 0);
+
             return this;
          }
          case 2:
          {
-            // size, center
-            m [0] = size .x / 2; m [1] = 0;           m [2] = 0;
-            m [3] = 0;           m [4] = size .y / 2; m [5] = 0;
-            m [6] = center .x;   m [7] = center .y;   m [8] = 1;
+            this .matrix .set (size .x / 2, 0, 0,
+                               0, size .y / 2, 0,
+                               center .x, center .y, 1);
+
             return this;
          }
          case 3:
          {
-            const
-               min = arguments [0],
-               max = arguments [1],
-               sx  = (max .x - min .x) / 2,
-               sy  = (max .y - min .y) / 2,
-               cx  = (max .x + min .x) / 2,
-               cy  = (max .y + min .y) / 2;
-
-            this .matrix .set (sx, 0,  0,
-                               0,  sy, 0,
-                               cx, cy, 1);
-            return this;
+            return this .setExtents (arguments [0], arguments [1]);
          }
       }
    },
@@ -149,9 +108,10 @@ Box2 .prototype =
          cx = (max .x + min .x) / 2,
          cy = (max .y + min .y) / 2;
 
-      m [0] = sx; m [1] = 0;  m [2] = 0;
-      m [3] = 0;  m [4] = sy; m [5] = 0;
-      m [6] = cx; m [7] = cy; m [8] = 1;
+      this .matrix .set (sx,  0, 0,
+                          0, sy, 0,
+                         cx, cy, 1);
+
       return this;
    },
    isEmpty: function ()

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

@@ -52,43 +52,9 @@ import SAT       from "../Algorithms/SAT.js";
 
 function Box3 (size, center)
 {
-   switch (arguments .length)
-   {
-      case 0:
-      {
-         this .matrix = new Matrix4 (0, 0, 0, 0,
-                                     0, 0, 0, 0,
-                                     0, 0, 0, 0,
-                                     0, 0, 0, 0);
-         return;
-      }
-      case 2:
-      {
-         this .matrix = new Matrix4 (size .x / 2, 0, 0, 0,
-                                     0, size .y / 2, 0, 0,
-                                     0, 0, size .z / 2, 0,
-                                     center .x, center .y, center .z, 1);
-         return;
-      }
-      case 3:
-      {
-         const
-            min = arguments [0],
-            max = arguments [1],
-            sx  = (max .x - min .x) / 2,
-            sy  = (max .y - min .y) / 2,
-            sz  = (max .z - min .z) / 2,
-            cx  = (max .x + min .x) / 2,
-            cy  = (max .y + min .y) / 2,
-            cz  = (max .z + min .z) / 2;
-
-         this .matrix = new Matrix4 (sx, 0,  0,  0,
-                                     0,  sy, 0,  0,
-                                     0,  0,  sz, 0,
-                                     cx, cy, cz, 1);
-         return;
-      }
-   }
+   this .matrix = new Matrix4 ();
+
+   this .set (... arguments);
 }
 
 Box3 .prototype =
@@ -115,43 +81,29 @@ Box3 .prototype =
    },
    set: function (size, center)
    {
-      const m = this .matrix;
-
       switch (arguments .length)
       {
          case 0:
          {
-            m [ 0] = 0.5; m [ 1] = 0;   m [ 2] = 0;   m [ 3] = 0;
-            m [ 4] = 0;   m [ 5] = 0.5; m [ 6] = 0;   m [ 7] = 0;
-            m [ 8] = 0;   m [ 9] = 0;   m [10] = 0.5; m [11] = 0;
-            m [12] = 0;   m [13] = 0;   m [14] = 0;   m [15] = 0;
+            this .matrix .set (0, 0, 0, 0,
+                               0, 0, 0, 0,
+                               0, 0, 0, 0,
+                               0, 0, 0, 0);
+
             return this;
          }
          case 2:
          {
-            m [ 0] = size .x / 2; m [ 1] = 0;           m [ 2] = 0;           m [ 3] = 0;
-            m [ 4] = 0;           m [ 5] = size .y / 2; m [ 6] = 0;           m [ 7] = 0;
-            m [ 8] = 0;           m [ 9] = 0;           m [10] = size .z / 2; m [11] = 0;
-            m [12] = center .x;   m [13] = center .y;   m [14] = center .z;   m [15] = 1;
+            this .matrix .set (size .x / 2, 0, 0, 0,
+                               0, size .y / 2, 0, 0,
+                               0, 0, size .z / 2, 0,
+                               center .x, center .y, center .z, 1);
+
             return this;
          }
          case 3:
          {
-            const
-               min = arguments [0],
-               max = arguments [1],
-               sx  = (max .x - min .x) / 2,
-               sy  = (max .y - min .y) / 2,
-               sz  = (max .z - min .z) / 2,
-               cx  = (max .x + min .x) / 2,
-               cy  = (max .y + min .y) / 2,
-               cz  = (max .z + min .z) / 2;
-
-            this .matrix .set (sx, 0,  0,  0,
-                               0,  sy, 0,  0,
-                               0,  0,  sz, 0,
-                               cx, cy, cz, 1);
-            return this;
+            return this .setExtents (arguments [0], arguments [1]);
          }
       }
    },
@@ -166,10 +118,11 @@ Box3 .prototype =
          cy = (max .y + min .y) / 2,
          cz = (max .z + min .z) / 2;
 
-      m [ 0] = sx; m [ 1] = 0;  m [ 2] = 0;  m [ 3] = 0;
-      m [ 4] = 0;  m [ 5] = sy; m [ 6] = 0;  m [ 7] = 0;
-      m [ 8] = 0;  m [ 9] = 0;  m [10] = sz; m [11] = 0;
-      m [12] = cx; m [13] = cy; m [14] = cz; m [15] = 1;
+      this .matrix .set (sx, 0,  0,  0,
+                         0,  sy, 0,  0,
+                         0,  0,  sz, 0,
+                         cx, cy, cz, 1);
+
       return this;
    },
    getExtents: function (min, max)

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

@@ -93,73 +93,30 @@ const Triangle3 = {
    },
    triangulatePolygon: (function ()
    {
-      const tessy = (function ()
-      {
-         // Function called for each vertex of tesselator output.
-         function vertexCallback (data, polyVertArray)
-         {
-            //console .log (data);
-            polyVertArray [polyVertArray .length] = data;
-         }
-
-         function beginCallback (type)
-         {
-            if (type !== libtess .primitiveType .GL_TRIANGLES)
-               console .log ('expected TRIANGLES but got type: ' + type);
-         }
-
-         function errorCallback (errno)
-         {
-            console .log ('error callback');
-            console .log ('error number: ' + errno);
-         }
-
-         // Callback for when segments intersect and must be split.
-         function combineCallback (coords, data, weight)
-         {
-            //console.log ('combine callback');
-            return data [0];
-         }
-
-         function edgeCallback (flag)
-         {
-            // Don't really care about the flag, but need no-strip/no-fan behavior.
-            // console .log ('edge flag: ' + flag);
-         }
+      // Function called for each vertex of tesselator output.
 
-         const tessy = new libtess .GluTesselator ();
+      function vertexCallback (index, triangles)
+      {
+         triangles .push (index);
+      }
 
-         tessy .gluTessCallback (libtess .gluEnum .GLU_TESS_VERTEX_DATA,  vertexCallback);
-         tessy .gluTessCallback (libtess .gluEnum .GLU_TESS_BEGIN,        beginCallback);
-         tessy .gluTessCallback (libtess .gluEnum .GLU_TESS_ERROR,        errorCallback);
-         tessy .gluTessCallback (libtess .gluEnum .GLU_TESS_COMBINE,      combineCallback);
-         tessy .gluTessCallback (libtess .gluEnum .GLU_TESS_EDGE_FLAG,    edgeCallback);
-         tessy .gluTessProperty (libtess .gluEnum .GLU_TESS_TOLERANCE,    0);
-         tessy .gluTessProperty (libtess .gluEnum .GLU_TESS_WINDING_RULE, libtess .windingRule .GLU_TESS_WINDING_ODD);
+      const tessy = new libtess .GluTesselator ();
 
-         return tessy;
-      })();
+      tessy .gluTessCallback (libtess .gluEnum .GLU_TESS_VERTEX_DATA,  vertexCallback);
+      tessy .gluTessProperty (libtess .gluEnum .GLU_TESS_WINDING_RULE, libtess .windingRule .GLU_TESS_WINDING_ODD);
 
-      return function (/* contour, [ contour, ..., ] triangles */)
+      return function (polygon, triangles)
       {
-         const triangles = arguments [arguments .length - 1];
-
          tessy .gluTessBeginPolygon (triangles);
+         tessy .gluTessBeginContour ();
 
-         for (let i = 0, length = arguments .length - 1; i < length; ++ i)
-         {
-            tessy .gluTessBeginContour ();
-
-            for (const contour of arguments [i])
-            {
-               tessy .gluTessVertex (contour, contour);
-            }
-
-            tessy .gluTessEndContour ();
-         }
+         for (const point of polygon)
+            tessy .gluTessVertex (point, point .index);
 
+         tessy .gluTessEndContour ();
          tessy .gluTessEndPolygon ();
 
+         // Return array of indices.
          return triangles;
       };
    })(),
@@ -169,28 +126,6 @@ const Triangle3 = {
       for (let i = 1, length = vertices .length - 1; i < length; ++ i)
          triangles .push (vertices [0], vertices [i], vertices [i + 1]);
    },
-   getPolygonNormal: function (vertices, normal)
-   {
-      // Determine polygon normal.
-      // We use Newell's method https://www.opengl.org/wiki/Calculating_a_Surface_Normal here:
-
-      normal .set (0, 0, 0);
-
-      var next = vertices [0];
-
-      for (let i = 0, length = vertices .length; i < length; ++ i)
-      {
-         var
-            current = next,
-            next    = vertices [(i + 1) % length];
-
-         normal .x += (current .y - next .y) * (current .z + next .z);
-         normal .y += (current .z - next .z) * (current .x + next .x);
-         normal .z += (current .x - next .x) * (current .y + next .y);
-      }
-
-      return normal .normalize ();
-   },
 };
 
 export default Triangle3;

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

@@ -93,12 +93,14 @@ Color3 .prototype =
       this [_r] = color [_r];
       this [_g] = color [_g];
       this [_b] = color [_b];
+      return this;
    },
    set: function (r, g, b)
    {
       this [_r] = clamp (r, 0, 1);
       this [_g] = clamp (g, 0, 1);
       this [_b] = clamp (b, 0, 1);
+      return this;
    },
    equals: function (color)
    {
@@ -173,6 +175,8 @@ Color3 .prototype =
             default: this [_r] = v; this [_g] = p; this [_b] = q; break;
          }
       }
+      
+      return this;
    },
    toString: function ()
    {

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

@@ -100,6 +100,7 @@ Color4 .prototype =
       this [_g] = color [_g];
       this [_b] = color [_b];
       this [_a] = color [_a];
+      return this;
    },
    set: function (r, g, b, a)
    {
@@ -107,6 +108,7 @@ Color4 .prototype =
       this [_g] = clamp (g, 0, 1);
       this [_b] = clamp (b, 0, 1);
       this [_a] = clamp (a, 0, 1);
+      return this;
    },
    equals: function (color)
    {
@@ -128,6 +130,8 @@ Color4 .prototype =
       Color3 .prototype .setHSV .call (this, h, s, v);
 
       this [_a] = clamp (a, 0, 1);
+
+      return this;
    },
    toString: function ()
    {