x_ite 8.6.0 → 8.6.2

package/docs/assets/css/style.scss

@@ -23,6 +23,7 @@ $tab-count: {{ site.tabs | size | plus: 1 }}; // plus 1 for home tab
   --system-yellow: rgb(255, 214, 10);
   --system-blue: rgb(10, 132, 255);
   --system-green: rgb(48, 209, 88);
+  --playground-editor-background: rgba(0, 0, 0, 0.2);
 }
 
 @mixin x_ite-light-scheme {
@@ -36,67 +37,26 @@ $tab-count: {{ site.tabs | size | plus: 1 }}; // plus 1 for home tab
   --system-yellow: rgb(255, 204, 0);
   --system-blue: rgb(0, 122, 255);
   --system-green: rgb(52, 199, 89);
-}
-
-@mixin playground-dark-scheme {
-  --playground-editor-background: rgba(0, 0, 0, 0.2);
-  --playground-editor-gutter: rgba(255, 255, 255, 0.05);
-  --playground-editor-active-line: rgb(32, 45, 64);
-  --playground-editor-selected-word: rgb(39, 79, 121);
-  --playground-xml-tag: var(--text-color);
-  --playground-xml-tag-name: rgb(90, 156, 216);
-  --playground-xml-attribute-name: rgb(159, 220, 254);
-  --playground-xml-attribute-equals: rgb(212, 212, 212);
-  --playground-xml-attribute-value: rgb(205, 145, 119);
-  --playground-json-parenthesis: rgb(253, 214, 1);
-  --playground-json-identifier: rgb(159, 220, 254);
-  --playground-json-variable: rgb(159, 220, 254);
-  --playground-json-numeric: rgb(183, 206, 165);
-  --playground-json-string: rgb(205, 145, 119);
-  --playground-json-boolean: rgb(90, 156, 216);
-  --playground-json-punctuation: rgb(212, 212, 212);
-}
-
-@mixin playground-light-scheme {
-  --playground-editor-background: rgba(0, 0, 0, 0.01);
-  --playground-editor-gutter: rgb(243, 243, 243);
-  --playground-editor-active-line: rgb(215, 229, 248);
-  --playground-editor-selected-word: rgb(174, 214, 255);
-  --playground-xml-tag: var(--text-color);
-  --playground-xml-tag-name: rgb(126, 0, 0);
-  --playground-xml-attribute-name: rgb(226, 2, 0);
-  --playground-xml-attribute-equals: rgb(0, 0, 0);
-  --playground-xml-attribute-value: rgb(16, 0, 255);
-  --playground-json-parenthesis: rgb(54, 147, 39);
-  --playground-json-identifier: rgb(18, 81, 166);
-  --playground-json-variable: rgb(18, 81, 166);
-  --playground-json-numeric: rgb(30, 134, 87);
-  --playground-json-string: rgb(160, 21, 21);
-  --playground-json-boolean: rgb(16, 0, 255);
-  --playground-json-punctuation: rgb(0, 0, 0);
+  --playground-editor-background: rgba(0, 0, 0, 0.03);
 }
 
 @media (prefers-color-scheme: dark) {
   html:not([data-mode]), html[data-mode=dark] {
     @include x_ite-dark-scheme;
-    @include playground-dark-scheme;
   }
 
   html[data-mode=light] {
     @include x_ite-light-scheme;
-    @include playground-light-scheme;
   }
 }
 
 @media (prefers-color-scheme: light) {
   html[data-mode=dark] {
     @include x_ite-dark-scheme;
-    @include playground-dark-scheme;
   }
 
   html:not([data-mode]), html[data-mode=light] {
     @include x_ite-light-scheme;
-    @include playground-light-scheme;
   }
 }
 

package/docs/laboratory/3d-l-system-generator.html

@@ -3,7 +3,7 @@ title: 3D L-System Generator
 layout: wide
 collection: tabs
 categories: [Laboratory]
-tags: [3D, l-system, generator]
+tags: [3D, L-System, Generator]
 ---
 <style>
 .row, .post, .post-content {

package/docs/laboratory/gltf-sample-viewer.html

@@ -3,7 +3,7 @@ title: glTF Sample Viewer
 layout: wide
 collection: tabs
 categories: [Laboratory]
-tags: [glTF, sample, viewer]
+tags: [glTF, Sample, Viewer]
 ---
 <style>
 .post, .post-content {

package/docs/laboratory/online-dicom-and-nrrd-file-viewer.html

@@ -3,7 +3,7 @@ title: Online DICOM and NRRD file Viewer
 layout: wide
 collection: tabs
 categories: [Laboratory]
-tags: [online, dicom, nrrd, file, viewer]
+tags: [Online, DICOM, NRRD, File, Viewer]
 ---
 <style>
 .row, .post, .post-content {

package/docs/laboratory/real-time-earth-quake-information.html

@@ -3,7 +3,7 @@ title: Real Time Earth Quake Information
 layout: wide
 collection: tabs
 categories: [Laboratory]
-tags: [real time, earth quake]
+tags: [Real Time, Earth Quake]
 ---
 <style>
 /* Table */

package/docs/laboratory/x3d-visual-blend-mode-editor.html

@@ -3,7 +3,7 @@ title: X3D Visual Blend Mode Editor
 layout: wide
 collection: tabs
 categories: [Laboratory]
-tags: [X3D, visual, blend mode, editor]
+tags: [X3D, Visual, Blend Mode, Editor]
 ---
 <link rel="stylesheet" type="text/css" href="https://cdn.jsdelivr.net/gh/cferdinandi/tabby@12.0.0/dist/css/tabby-ui.min.css">
 <script src="https://cdn.jsdelivr.net/gh/cferdinandi/tabby@12.0.0/dist/js/tabby.polyfills.min.js"></script>

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "x_ite",
-	"version": "8.6.0",
+	"version": "8.6.2",
 	"description": "X_ITE X3D Browser, view and manipulate X3D and VRML scenes in HTML.",
 	"homepage": "https://create3000.github.io/x_ite/",
 	"author": "Holger Seelig <holger.seelig@gmail.com>",

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

@@ -47,235 +47,186 @@
 
 import Algorithm from "../Algorithm.js";
 import Vector2   from "../Numbers/Vector2.js";
+import Vector3   from "../Numbers/Vector3.js";
+import Vector4   from "../Numbers/Vector4.js";
+import Matrix3   from "../Numbers/Matrix3.js";
+import Matrix4   from "../Numbers/Matrix4.js";
 
-const lerp = Algorithm .lerp;
+const { interval } = Algorithm;
 
-function Bezier (/*x0, y0, x1, y1, x2, y2, x3, y3*/)
-{
-   this .args = arguments;
-}
+// https://pomax.github.io/bezierinfo/
 
-Bezier .prototype =
+const Bezier =
 {
-   getPoints: function (type, steps)
+   quadric: (function ()
    {
-      const points = [ ];
+      const
+         c = new Matrix3 (1, 0, 0, -2, 2, 0, 1, -2, 1),
+         p = new Matrix3 ();
 
-      switch (type)
+      return function (x0, y0, z0, x1, y1, z1, x2, y2, z2, steps, points)
       {
-         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":
+         p .set (x0, y0, z0, x1, y1, z1, x2, y2, z2)
+            .multLeft (c);
+
+         for (let i = 0, d = steps - 1; i < steps; ++ 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)
-            {
-               points .push (cubic (x0, y0, x1, y1, x2, y2, x3, y3, i / d));
-            }
-
-            break;
+            const t = i / d;
+
+            points .push (p .multVecMatrix (new Vector3 (1, t, t * t)));
          }
-         case "arc":
-         {
-            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];
+      };
+   })(),
+   cubic: (function ()
+   {
+      const
+         v = new Vector4 (0, 0, 0, 0),
+         c = new Matrix4 (1, 0, 0, 0, -3, 3, 0, 0, 3, -6, 3, 0, -1, 3, -3, 1),
+         p = new Matrix4 ();
 
-            // https://ericeastwood.com/blog/25/curves-and-arcs-quadratic-cubic-elliptical-svg-implementations
-            // See https://www.w3.org/TR/SVG/implnote.html#ArcImplementationNotes.
+      return function (x0, y0, z0, x1, y1, z1, x2, y2, z2, x3, y3, z3, steps, points)
+      {
+         p .set (x0, y0, z0, 0, x1, y1, z1, 0, x2, y2, z2, 0, x3, y3, z3, 0)
+            .multLeft (c);
 
-            // If the endpoints are identical, then this is equivalent to omitting the elliptical arc segment entirely.
-            if (ax === x && ay === y)
-            {
-               points .push (new Vector2 (x, y));
-               return;
-            }
+         for (let i = 0, d = steps - 1; i < steps; ++ i)
+         {
+            const t = i / d;
 
-            // In accordance to: http://www.w3.org/TR/SVG/implnote.html#ArcOutOfRangeParameters
+            p .multVecMatrix (v .set (1, t, t * t, t * t * t));
 
-            rx = Math .abs (rx);
-            ry = Math .abs (ry);
+            points .push (new Vector3 (v .x, v .y, v .z));
+         }
+      };
+   })(),
+   arc: function (ax, ay, rx, ry, xAxisRotation, largeArcFlag, sweepFlag, x, y, steps, points)
+   {
+      // https://ericeastwood.com/blog/25/curves-and-arcs-quadratic-cubic-elliptical-svg-implementations
+      // See https://www.w3.org/TR/SVG/implnote.html#ArcImplementationNotes.
 
-            // 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;
-            }
+      // If the endpoints are identical, then this is equivalent to omitting the elliptical arc segment entirely.
+      if (ax === x && ay === y)
+      {
+         points .push (new Vector3 (x, y, 0));
+         return;
+      }
 
-            const
-               rx2 = rx * rx,
-               ry2 = ry * ry;
+      // In accordance to: http://www.w3.org/TR/SVG/implnote.html#ArcOutOfRangeParameters
 
-            // In accordance to: http://www.w3.org/TR/SVG/implnote.html#ArcOutOfRangeParameters
+      rx = Math .abs (rx);
+      ry = Math .abs (ry);
 
-            xAxisRotation = Algorithm .interval (xAxisRotation, 0, 2 * Math .PI);
+      // 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 Vector3 (ax, ay, 0), new Vector3 (x, y, 0));
+         return;
+      }
 
-            const
-               sinRotation = Math .sin (xAxisRotation),
-               cosRotation = Math .cos (xAxisRotation);
+      const
+         rx2 = rx * rx,
+         ry2 = ry * ry;
 
-            // Following "Conversion from endpoint to center parameterization"
-            // http://www.w3.org/TR/SVG/implnote.html#ArcConversionEndpointToCenter
+      // In accordance to: http://www.w3.org/TR/SVG/implnote.html#ArcOutOfRangeParameters
 
-            // Step #1: Compute transformedPoint
-            const d = new Vector2 (ax - x, ay - y) .divide (2);
+      xAxisRotation = interval (xAxisRotation, 0, 2 * Math .PI);
 
-            const transformedPoint = new Vector2 ( cosRotation * d .x + sinRotation * d .y,
-                                                  -sinRotation * d .x + cosRotation * d .y);
+      const
+         sinRotation = Math .sin (xAxisRotation),
+         cosRotation = Math .cos (xAxisRotation);
 
-            const transformedPoint2 = transformedPoint .copy () .multVec (transformedPoint);
+      // Following "Conversion from endpoint to center parameterization"
+      // http://www.w3.org/TR/SVG/implnote.html#ArcConversionEndpointToCenter
 
-            // Ensure radii are large enough
-            const radiiCheck = transformedPoint2 .x / rx2 + transformedPoint2 .y / ry2;
+      // Step #1: Compute transformedPoint
+      const d = new Vector2 (ax - x, ay - y) .divide (2);
 
-            if (radiiCheck > 1)
-            {
-               rx = Math .sqrt (radiiCheck) * rx;
-               ry = Math .sqrt (radiiCheck) * ry;
-            }
+      const transformedPoint = new Vector2 ( cosRotation * d .x + sinRotation * d .y,
+                                             -sinRotation * d .x + cosRotation * d .y);
 
-            // 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;
+      const transformedPoint2 = transformedPoint .copy () .multVec (transformedPoint);
 
-            // Make sure this never drops below zero because of precision
-            cRadicand = Math .max (0, cRadicand);
+      // Ensure radii are large enough
+      const radiiCheck = transformedPoint2 .x / rx2 + transformedPoint2 .y / ry2;
 
-            const cCoef = (largeArcFlag !== sweepFlag ? 1 : -1) * Math .sqrt (cRadicand);
+      if (radiiCheck > 1)
+      {
+         rx = Math .sqrt (radiiCheck) * rx;
+         ry = Math .sqrt (radiiCheck) * ry;
+      }
 
-            const transformedCenter = new Vector2 ( cCoef * rx * transformedPoint .y / ry,
-                                                   -cCoef * ry * transformedPoint .x / rx);
+      // 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;
 
-            // 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));
+      // Make sure this never drops below zero because of precision
+      cRadicand = Math .max (0, cRadicand);
 
-            // Step #4: Compute start/sweep angles
-            const startVector = new Vector2 ((transformedPoint .x - transformedCenter .x) / rx,
-                                             (transformedPoint .y - transformedCenter .y) / ry);
+      const cCoef = (largeArcFlag !== sweepFlag ? 1 : -1) * Math .sqrt (cRadicand);
 
-            const endVector = new Vector2 ((-transformedPoint .x - transformedCenter .x) / rx,
-                                           (-transformedPoint .y - transformedCenter .y) / ry);
+      const transformedCenter = new Vector2 ( cCoef * rx * transformedPoint .y / ry,
+                                             -cCoef * ry * transformedPoint .x / rx);
 
-            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));
+      // 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));
 
-            let sweepAngle = endAngle - startAngle;
+      // Step #4: Compute start/sweep angles
+      const startVector = new Vector2 ((transformedPoint .x - transformedCenter .x) / rx,
+                                       (transformedPoint .y - transformedCenter .y) / ry);
 
-            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;
-            }
+      const endVector = new Vector2 ((-transformedPoint .x - transformedCenter .x) / rx,
+                                     (-transformedPoint .y - transformedCenter .y) / ry);
 
-            if (sweepFlag && sweepAngle < 0)
-               sweepAngle += 2 *Math .PI;
+      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));
 
-            else if (!sweepFlag && sweepAngle > 0)
-               sweepAngle -= 2 * Math .PI;
+      let sweepAngle = endAngle - startAngle;
 
-            // Interpolate:
+      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;
+      }
 
-            const bezier_steps   = Math .max (4, Math .abs (sweepAngle) * steps / (2 * Math .PI));
-            const bezier_steps_1 = bezier_steps - 1;
+      if (sweepFlag && sweepAngle < 0)
+         sweepAngle += 2 *Math .PI;
 
-            points .push (new Vector2 (ax, ay));
+      else if (!sweepFlag && sweepAngle > 0)
+         sweepAngle -= 2 * Math .PI;
 
-            for (let i = 1; i < bezier_steps_1; ++ i)
-            {
-               const t = i / bezier_steps_1;
+      // Interpolate:
 
-               // 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 bezier_steps   = Math .max (4, Math .abs (sweepAngle) * steps / (2 * Math .PI));
+      const bezier_steps_1 = bezier_steps - 1;
 
-               const point = new Vector2 (cosRotation * x - sinRotation * y + center .x,
-                                          sinRotation * x + cosRotation * y + center .y);
+      points .push (new Vector3 (ax, ay, 0));
 
-               points .push (point);
-            }
+      for (let i = 1; i < bezier_steps_1; ++ i)
+      {
+         const t = i / bezier_steps_1;
 
-            points .push (new Vector2 (x, y));
-            break;
-         }
+         // 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);
+
+         points .push (new Vector3 (cosRotation * x - sinRotation * y + center .x,
+                                    sinRotation * x + cosRotation * y + center .y,
+                                    0));
       }
 
-      return points;
+      points .push (new Vector3 (x, y, 0));
    }
 };
 
-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 new Vector2 (bx0, 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 new Vector2 (cx0, cy0);
-}
-
 export default Bezier;

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

@@ -102,7 +102,6 @@ Box2 .prototype =
    setExtents: function (min, max)
    {
       const
-         m  = this .matrix,
          sx = (max .x - min .x) / 2,
          sy = (max .y - min .y) / 2,
          cx = (max .x + min .x) / 2,

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

@@ -110,7 +110,6 @@ Box3 .prototype =
    setExtents: function (min, max)
    {
       const
-         m  = this .matrix,
          sx = (max .x - min .x) / 2,
          sy = (max .y - min .y) / 2,
          sz = (max .z - min .z) / 2,

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

@@ -120,7 +120,7 @@ Cylinder3 .prototype =
          pos = line .point,
          dir = line .direction;
 
-         const
+      const
          A = dir [0] * dir [0] + dir [2] * dir [2],
          B = 2 * (pos [0] * dir [0] + pos [2] * dir [2]),
          C = pos [0] * pos [0] + pos [2] * pos [2] - 1;

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

@@ -119,10 +119,8 @@ Line2 .prototype =
       return function (line, point)
       {
          const
-            p1 = this .point,
-            p2 = line .point,
-            d1 = this .direction,
-            d2 = line .direction;
+            { point: p1, direction: d1 } = this,
+            { point: p2, direction: d2 } = line;
 
          const theta = d1 .dot (d2); // angle between both lines
 

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

@@ -108,10 +108,8 @@ Line3 .prototype =
       return function (line, point)
       {
          const
-            p1 = this .point,
-            p2 = line .point,
-            d1 = this .direction,
-            d2 = line .direction;
+            { point: p1, direction: d1 } = this,
+            { point: p2, direction: d2 } = line;
 
          let t = d1 .dot (d2);
 

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

@@ -137,9 +137,7 @@ Plane3 .prototype =
    },
    intersectsLine: function (line, intersection)
    {
-      const
-         point     = line .point,
-         direction = line .direction;
+      const { point, direction } = line;
 
       // Check if the line is parallel to the plane.
       const theta = direction .dot (this .normal);

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

@@ -66,18 +66,14 @@ Sphere3 .prototype =
       // https://github.com/Alexpux/Coin3D/blob/master/src/base/SbSphere.cpp
 
       const
-         linepos = line .point,
-         linedir = line .direction;
+         { point, direction } = line,
+         { center, radius }   = this;
 
       const
-         scenter = this .center,
-         r       = this .radius;
-
-      const
-         b = 2 * (linepos .dot (linedir) - scenter .dot (linedir)),
-         c = (linepos .x * linepos .x + linepos .y * linepos .y + linepos .z * linepos .z) +
-             (scenter .x * scenter .x + scenter .y * scenter .y + scenter .z * scenter .z) -
-             2 * linepos .dot (scenter) - r * r;
+         b = 2 * (point .dot (direction) - center .dot (direction)),
+         c = (point .x * point .x + point .y * point .y + point .z * point .z) +
+             (center .x * center .x + center .y * center .y + center .z * center .z) -
+             2 * point .dot (center) - radius * radius;
 
       const core = b * b - 4 * c;
 
@@ -94,8 +90,8 @@ Sphere3 .prototype =
             t2 = tmp;
          }
 
-         enterPoint .assign (linedir) .multiply (t1) .add (linepos);
-         exitPoint  .assign (linedir) .multiply (t2) .add (linepos);
+         enterPoint .assign (direction) .multiply (t1) .add (point);
+         exitPoint  .assign (direction) .multiply (t2) .add (point);
 
          return true;
       }

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

@@ -100,9 +100,17 @@ const Triangle3 = {
          triangles .push (index);
       }
 
+      // Required in case of a combine, otherwise an empty array is returned.
+
+      function combineCallback (coords, data, weight)
+      {
+         return data [0];
+      }
+
       const tessy = new libtess .GluTesselator ();
 
       tessy .gluTessCallback (libtess .gluEnum .GLU_TESS_VERTEX_DATA,  vertexCallback);
+      tessy .gluTessCallback (libtess .gluEnum .GLU_TESS_COMBINE,      combineCallback);
       tessy .gluTessProperty (libtess .gluEnum .GLU_TESS_WINDING_RULE, libtess .windingRule .GLU_TESS_WINDING_ODD);
 
       return function (polygon, triangles)