x_ite 8.4.3 → 8.5.3

package/src/x_ite/Browser/Text/PolygonText.js

@@ -50,8 +50,8 @@ import X3DTextGeometry  from "./X3DTextGeometry.js";
 import X3DGeometryNode  from "../../Components/Rendering/X3DGeometryNode.js";
 import Vector3          from "../../../standard/Math/Numbers/Vector3.js";
 import Matrix4          from "../../../standard/Math/Numbers/Matrix4.js";
-import Triangle3        from "../../../standard/Math/Geometry/Triangle3.js";
 import Bezier           from "../../../standard/Math/Algorithms/Bezier.js";
+import libtess          from "../../../lib/libtess.js";
 
 function PolygonText (text, fontStyle)
 {
@@ -75,20 +75,20 @@ PolygonText .prototype = Object .assign (Object .create (X3DTextGeometry .protot
    },
    build: (function ()
    {
-      var
+      const
          min = new Vector3 (0, 0, 0),
          max = new Vector3 (0, 0, 0);
 
       return function ()
       {
-         var
+         const
             fontStyle = this .getFontStyle (),
             font      = fontStyle .getFont ();
 
-         if (! font)
+         if (!font)
             return;
 
-         var
+         const
             text             = this .getText (),
             glyphs           = this .getGlyphs (),
             minorAlignment   = this .getMinorAlignment (),
@@ -113,25 +113,26 @@ PolygonText .prototype = Object .assign (Object .create (X3DTextGeometry .protot
 
          if (fontStyle ._horizontal .getValue ())
          {
-            for (var l = 0, length = glyphs .length; l < length; ++ l)
+            for (let l = 0, length = glyphs .length; l < length; ++ l)
             {
-               var
-                  line         = glyphs [l],
-                  charSpacing  = charSpacings [l],
-                  translation  = translations [l],
-                  advanceWidth = 0;
+               const
+                  line        = glyphs [l],
+                  charSpacing = charSpacings [l],
+                  translation = translations [l];
 
-               for (var g = 0, gl = line .length; g < gl; ++ g)
+               let advanceWidth = 0;
+
+               for (let g = 0, gl = line .length; g < gl; ++ g)
                {
-                  var
+                  const
                      glyph         = line [g],
                      glyphVertices = this .getGlyphGeometry (font, glyph, primitiveQuality),
                      xOffset       = minorAlignment .x + translation .x + advanceWidth + g * charSpacing,
                      yOffset       = minorAlignment .y + translation .y;
 
-                  for (var v = 0, vl = glyphVertices .length; v < vl; ++ v)
+                  for (let v = 0, vl = glyphVertices .length; v < vl; ++ v)
                   {
-                     var
+                     const
                         x = glyphVertices [v] .x * size + xOffset,
                         y = glyphVertices [v] .y * size + yOffset;
 
@@ -142,7 +143,7 @@ PolygonText .prototype = Object .assign (Object .create (X3DTextGeometry .protot
 
                   // Calculate advanceWidth.
 
-                  var kerning = 0;
+                  let kerning = 0;
 
                   if (g + 1 < line .length)
                      kerning = font .getKerningValue (glyph, line [g + 1]);
@@ -153,32 +154,31 @@ PolygonText .prototype = Object .assign (Object .create (X3DTextGeometry .protot
          }
          else
          {
-            var
+            const
                leftToRight = fontStyle ._leftToRight .getValue (),
                topToBottom = fontStyle ._topToBottom .getValue (),
                first       = leftToRight ? 0 : text ._string .length - 1,
                last        = leftToRight ? text ._string .length  : -1,
                step        = leftToRight ? 1 : -1;
 
-            for (var l = first, t = 0; l !== last; l += step)
+            for (let l = first, t = 0; l !== last; l += step)
             {
-               var line = glyphs [l];
-
-               var
+               const
+                  line     = glyphs [l],
                   numChars = line .length,
                   firstG   = topToBottom ? 0 : numChars - 1,
                   lastG    = topToBottom ? numChars : -1,
                   stepG    = topToBottom ? 1 : -1;
 
-               for (var g = firstG; g !== lastG; g += stepG, ++ t)
+               for (let g = firstG; g !== lastG; g += stepG, ++ t)
                {
-                  var
+                  const
                      translation   = translations [t],
                      glyphVertices = this .getGlyphGeometry (font, line [g], primitiveQuality);
 
-                  for (var v = 0, vl = glyphVertices .length; v < vl; ++ v)
+                  for (let v = 0, vl = glyphVertices .length; v < vl; ++ v)
                   {
-                     var
+                     const
                         x = glyphVertices [v] .x * size + minorAlignment .x + translation .x,
                         y = glyphVertices [v] .y * size + minorAlignment .y + translation .y;
 
@@ -193,7 +193,7 @@ PolygonText .prototype = Object .assign (Object .create (X3DTextGeometry .protot
    })(),
    getGlyphExtents: function (font, glyph, primitiveQuality, min, max)
    {
-      var
+      const
          glyphCache = this .getBrowser () .getGlyph (font, primitiveQuality, glyph .index),
          extents    = glyphCache .extents;
 
@@ -201,150 +201,119 @@ PolygonText .prototype = Object .assign (Object .create (X3DTextGeometry .protot
       {
          min .assign (extents .min);
          max .assign (extents .max);
-         return;
       }
-
-      var vertices = this .getGlyphGeometry (font, glyph, primitiveQuality);
-
-      if (vertices .length)
+      else
       {
-         var vertex = vertices [0];
+         const vertices = this .getGlyphGeometry (font, glyph, primitiveQuality);
 
-         min .assign (vertex);
-         max .assign (vertex);
-
-         for (var i = 1, length = vertices .length; i < length; ++ i)
+         if (vertices .length)
          {
-            var vertex = vertices [i];
-
-            min .min (vertex);
-            max .max (vertex);
+            min .assign (vertices [0]) .min (... vertices);
+            max .assign (vertices [0]) .max (... vertices);
+         }
+         else
+         {
+            min .set (0, 0, 0);
+            max .set (0, 0, 0);
          }
-      }
-      else
-      {
-         min .set (0, 0, 0);
-         max .set (0, 0, 0);
-      }
 
-      var extents = glyphCache .extents = { };
+         const extents = glyphCache .extents = { };
 
-      extents .min = min .copy ();
-      extents .max = max .copy ();
+         extents .min = min .copy ();
+         extents .max = max .copy ();
+      }
    },
    getGlyphGeometry: function (font, glyph, primitiveQuality)
    {
-      var
+      const
          glyphCache    = this .getBrowser () .getGlyph (font, primitiveQuality, glyph .index),
          glyphGeometry = glyphCache .geometry;
 
       if (glyphGeometry)
+      {
          return glyphGeometry;
+      }
+      else
+      {
+         const glyphGeometry = glyphCache .geometry = [ ];
 
-      glyphGeometry = glyphCache .geometry = [ ];
-
-      this .createGlyphGeometry (glyph, glyphGeometry, primitiveQuality);
+         this .createGlyphGeometry (glyph, glyphGeometry, primitiveQuality);
 
-      return glyphGeometry;
+         return glyphGeometry;
+      }
    },
-   createGlyphGeometry: (function ()
+   createGlyphGeometry: function (glyph, vertices, primitiveQuality)
    {
-      var
-         points = [ ],
-         curves = [ ],
-         normal = new Vector3 (0, 0, 0);
+      // Get contours for the current glyph.
 
-      return function (glyph, vertices, primitiveQuality)
-      {
-         // Get curves for the current glyph.
+      const
+         steps = this .getBezierSteps (primitiveQuality),
+         path  = glyph .getPath (0, 0, 1);
 
-         var
-            dimension  = this .getBezierDimension (primitiveQuality),
-            path       = glyph .getPath (0, 0, 1),
-            commands   = path .commands,
-            x          = 0,
-            y          = 0;
+      let
+         contours = [ ],
+         points   = [ ],
+         x        = 0,
+         y        = 0;
 
-         points .length = 0;
-         curves .length = 0;
-
-         for (var i = 0, cl = commands .length; i < cl; ++ i)
+      for (const command of path .commands)
+      {
+         switch (command .type)
          {
-            var command = commands [i];
-
-            switch (command .type)
+            case "M": // Start
+            case "Z": // End
             {
-               case "M": // Start
-               case "Z": // End
-               {
-                  if (points .length > 2)
-                  {
-                     if (points [0] .x === points .at (-1) .x && points [0] .y === points .at (-1) .y)
-                        points .pop ();
-
-                     curves .push (points);
-                  }
+               // Filter consecutive identical points.
+               points = points .filter ((p, i, a) => !p .equals (a [(i + 1) % a .length]));
 
-                  points = [ ];
+               if (points .length > 2)
+                  contours .push (points);
 
-                  if (command .type === "M")
-                     points .push (new Vector3 (command .x, -command .y, 0));
+               points = [ ];
 
-                  break;
-               }
-               case "L": // Linear
-               {
+               if (command .type === "M")
                   points .push (new Vector3 (command .x, -command .y, 0));
-                  break;
-               }
-               case "Q": // Quadric
-               {
-                  var
-                     curve = new Bezier (x, -y, command .x1, -command .y1, command .x, -command .y),
-                     lut   = curve .getLUT (dimension);
 
-                  for (var l = 1, ll = lut .length; l < ll; ++ l)
-                     points .push (new Vector3 (lut [l] .x, lut [l] .y, 0));
-
-                  break;
-               }
-               case "C": // Cubic
-               {
-                  var
-                     curve = new Bezier (x, -y, command .x1, -command .y1, command .x2, -command .y2, command .x, -command .y),
-                     lut   = curve .getLUT (dimension);
-
-                  for (var l = 1, ll = lut .length; l < ll; ++ l)
-                     points .push (new Vector3 (lut [l] .x, lut [l] .y, 0));
-
-                  break;
-               }
-               default:
-                  continue;
+               break;
             }
+            case "L": // Linear
+            {
+               points .push (new Vector3 (command .x, -command .y, 0));
+               break;
+            }
+            case "Q": // Quadric
+            {
+               const
+                  curve = new Bezier (x, -y, command .x1, -command .y1, command .x, -command .y),
+                  lut   = curve .getPoints ("quadric", steps);
 
-            x = command .x;
-            y = command .y;
-         }
-
-         // Triangulate contours.
+               for (const p of lut)
+                  points .push (new Vector3 (p .x, p .y, 0));
 
-         curves = curves .map (function (curve)
-         {
-            Triangle3 .getPolygonNormal (curve, normal);
+               break;
+            }
+            case "C": // Cubic
+            {
+               const
+                  curve = new Bezier (x, -y, command .x1, -command .y1, command .x2, -command .y2, command .x, -command .y),
+                  lut   = curve .getPoints ("cubic", steps);
 
-            if (normal .dot (Vector3 .zAxis) > 0)
-               return curve;
+               for (const p of lut)
+                  points .push (new Vector3 (p .x, p .y, 0));
 
-            return curve .reverse ();
-         });
+               break;
+            }
+            default:
+               continue;
+         }
 
-         curves .push (vertices);
+         x = command .x;
+         y = command .y;
+      }
 
-         Triangle3 .triangulatePolygon .apply (Triangle3, curves);
-      };
-   })(),
-   getBezierDimension: function (primitiveQuality)
+      return this .triangulatePolygon (contours, vertices);
+   },
+   getBezierSteps: function (primitiveQuality)
    {
       switch (primitiveQuality)
       {
@@ -356,6 +325,40 @@ PolygonText .prototype = Object .assign (Object .create (X3DTextGeometry .protot
             return 5;
       }
    },
+   triangulatePolygon: (function ()
+   {
+      // Function called for each vertex of tessellator output.
+
+      function vertexCallback (point, triangles)
+      {
+         triangles .push (point);
+      }
+
+      const tessy = new libtess .GluTesselator ();
+
+      tessy .gluTessCallback (libtess .gluEnum .GLU_TESS_VERTEX_DATA,  vertexCallback);
+      tessy .gluTessProperty (libtess .gluEnum .GLU_TESS_WINDING_RULE, libtess .windingRule .GLU_TESS_WINDING_ODD);
+      tessy .gluTessNormal (0, 0, 1);
+
+      return function (contours, triangles)
+      {
+         tessy .gluTessBeginPolygon (triangles);
+
+         for (const points of contours)
+         {
+            tessy .gluTessBeginContour ();
+
+            for (const point of points)
+               tessy .gluTessVertex (point, point);
+
+            tessy .gluTessEndContour ();
+         }
+
+         tessy .gluTessEndPolygon ();
+
+         return triangles;
+      };
+   })(),
    display: function (gl, renderContext)
    { },
    transformLine: function (line)

package/src/x_ite/Browser/Texturing/GifMedia.js

@@ -0,0 +1,113 @@
+/*******************************************************************************
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright create3000, Scheffelstraße 31a, Leipzig, Germany 2011 - 2022.
+ *
+ * All rights reserved. Holger Seelig <holger.seelig@yahoo.de>.
+ *
+ * The copyright notice above does not evidence any actual of intended
+ * publication of such source code, and is an unpublished work by create3000.
+ * This material contains CONFIDENTIAL INFORMATION that is the property of
+ * create3000.
+ *
+ * No permission is granted to copy, distribute, or create derivative works from
+ * the contents of this software, in whole or in part, without the prior written
+ * permission of create3000.
+ *
+ * NON-MILITARY USE ONLY
+ *
+ * All create3000 software are effectively free software with a non-military use
+ * restriction. It is free. Well commented source is provided. You may reuse the
+ * source in any way you please with the exception anything that uses it must be
+ * marked to indicate is contains 'non-military use only' components.
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2011 - 2022, Holger Seelig <holger.seelig@yahoo.de>.
+ *
+ * This file is part of the X_ITE Project.
+ *
+ * X_ITE is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License version 3 only, as published by the
+ * Free Software Foundation.
+ *
+ * X_ITE is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the GNU General Public License version 3 for more
+ * details (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version 3
+ * along with X_ITE.  If not, see <https://www.gnu.org/licenses/gpl.html> for a
+ * copy of the GPLv3 License.
+ *
+ * For Silvio, Joy and Adi.
+ *
+ ******************************************************************************/
+
+function GifMedia (gif, movieTexture)
+{
+   let
+      cycle = 0,
+      loop  = false;
+
+   Object .defineProperties (gif,
+   {
+      currentTime:
+      {
+         get: function ()
+         {
+            if (!loop && cycle < this .cycle)
+               return this .duration;
+
+            return movieTexture ._elapsedTime % this .duration;
+         },
+         set: Function .prototype,
+      },
+      duration:
+      {
+         get: function ()
+         {
+            return this .get_duration_ms () / 1000;
+         },
+      },
+      loop:
+      {
+         get: function ()
+         {
+            return loop;
+         },
+         set: function (value)
+         {
+            cycle = this .cycle;
+            loop  = value;
+         },
+      },
+      cycle:
+      {
+         get: function ()
+         {
+            return Math .floor (movieTexture ._elapsedTime / this .duration);
+         },
+      },
+      currentFrame:
+      {
+         get: function ()
+         {
+            const length = this .get_length ();
+
+            return this .get_frames () [Math .max (Math .ceil (this .currentTime / this .duration * length) - 1, 0)];
+         },
+      },
+      play:
+      {
+         value: function ()
+         {
+            cycle = this .cycle;
+            return Promise .resolve ();
+         },
+      },
+   });
+}
+
+export default GifMedia;

package/src/x_ite/Browser/Texturing3D/DICOMParser.js

@@ -56,12 +56,7 @@ DicomParser .prototype =
    {
       try
       {
-         const inputArray = new Uint8Array (input .length);
-
-         for (let i = 0, length = input .length; i < length; ++ i)
-            inputArray [i] = input .charCodeAt (i);
-
-         this .dataSet      = dicomParser .parseDicom (inputArray);
+         this .dataSet      = dicomParser .parseDicom (new Uint8Array (input));
          this .dicom .dicom = true;
       }
       catch (error)