x_ite 8.9.1 → 8.9.3

package/src/x_ite/Components/Geometry3D/Extrusion.js

@@ -381,12 +381,12 @@ Object .assign (Object .setPrototypeOf (Extrusion .prototype, X3DGeometryNode .p
          // Create
 
          const
-            normalIndex = [ ],
+            normalIndex = new Map (),
             normals     = [ ],
             points      = this .createPoints ();
 
          for (let p = 0, length = points .length; p < length; ++ p)
-            normalIndex [p] = [ ];
+            normalIndex .set (p, [ ]);
 
          // Build body.
 
@@ -490,19 +490,19 @@ Object .assign (Object .setPrototypeOf (Extrusion .prototype, X3DGeometryNode .p
                      texCoordArray .push (k / numCrossSection_1, y, 0, 1);
                   }
 
-                  normalIndex [i1] .push (normals .length);
+                  normalIndex .get (i1) .push (normals .length);
                   normals .push (normal1);
                   vertexArray .push (p1 .x, p1 .y, p1 .z, 1);
 
                   // p2
                   texCoordArray .push ((k + 1) / numCrossSection_1, n / numSpine_1, 0, 1);
-                  normalIndex [i2] .push (normals .length);
+                  normalIndex .get (i2) .push (normals .length);
                   normals .push (normal1);
                   vertexArray .push (p2 .x, p2 .y, p2 .z, 1);
 
                   // p3
                   texCoordArray .push ((k + 1) / numCrossSection_1, (n + 1) / numSpine_1, 0, 1);
-                  normalIndex [i3] .push (normals .length);
+                  normalIndex .get (i3) .push (normals .length);
                   normals .push (normal1);
                   vertexArray .push (p3 .x, p3 .y, p3 .z, 1);
                }
@@ -513,7 +513,7 @@ Object .assign (Object .setPrototypeOf (Extrusion .prototype, X3DGeometryNode .p
                {
                   // p1
                   texCoordArray .push (k / numCrossSection_1, n / numSpine_1, 0, 1);
-                  normalIndex [i1] .push (normals .length);
+                  normalIndex .get (i1) .push (normals .length);
                   normals .push (normal2);
                   vertexArray .push (p1 .x, p1 .y, p1 .z, 1);
 
@@ -530,13 +530,13 @@ Object .assign (Object .setPrototypeOf (Extrusion .prototype, X3DGeometryNode .p
                      texCoordArray .push ((k + 1) / numCrossSection_1, y, 0, 1);
                   }
 
-                  normalIndex [i3] .push (normals .length);
+                  normalIndex .get (i3) .push (normals .length);
                   normals .push (normal2);
                   vertexArray .push (p3 .x, p3 .y, p3 .z, 1);
 
                   // p4
                   texCoordArray .push (k / numCrossSection_1, (n + 1) / numSpine_1, 0, 1);
-                  normalIndex [i4] .push (normals .length);
+                  normalIndex .get (i4) .push (normals .length);
                   normals .push (normal2);
                   vertexArray .push (p4 .x, p4 .y, p4 .z, 1);
                }
@@ -545,12 +545,10 @@ Object .assign (Object .setPrototypeOf (Extrusion .prototype, X3DGeometryNode .p
 
          // Refine body normals and add them.
 
-         const refineNormals = this .refineNormals (normalIndex, normals, this ._creaseAngle .getValue ());
+         const refinedNormals = this .refineNormals (normalIndex, normals, this ._creaseAngle .getValue ());
 
-         for (const normal of refineNormals)
-         {
+         for (const normal of refinedNormals)
             normalArray .push (normal .x, normal .y, normal .z);
-         }
 
          // Build caps
 

package/src/x_ite/Components/Geometry3D/IndexedFaceSet.js

@@ -319,80 +319,70 @@ Object .assign (Object .setPrototypeOf (IndexedFaceSet .prototype, X3DComposedGe
          }
       }
    },
-   createNormals: (() =>
+   createNormals (polygons)
    {
       const
-         normals     = [ ],
-         normalIndex = [ ];
+         cw          = !this ._ccw .getValue (),
+         coordIndex  = this ._coordIndex .getValue (),
+         coord       = this .getCoord (),
+         normalIndex = new Map (),
+         normals     = [ ];
 
-      return function (polygons)
+      for (const polygon of polygons)
       {
          const
-            cw         = ! this ._ccw .getValue (),
-            coordIndex = this ._coordIndex .getValue (),
-            coord      = this .getCoord ();
+            vertices = polygon .vertices,
+            length   = vertices .length;
 
-         normals     .length = 0;
-         normalIndex .length = 0;
-
-         for (const polygon of polygons)
+         switch (length)
          {
-            const
-               vertices = polygon .vertices,
-               length   = vertices .length;
-
-            switch (length)
+            case 3:
             {
-               case 3:
-               {
-                  var normal = coord .getNormal (coordIndex [vertices [0]],
-                                                 coordIndex [vertices [1]],
-                                                 coordIndex [vertices [2]]);
-                  break;
-               }
-               case 4:
-               {
-                  var normal = coord .getQuadNormal (coordIndex [vertices [0]],
-                                                     coordIndex [vertices [1]],
-                                                     coordIndex [vertices [2]],
-                                                     coordIndex [vertices [3]]);
-                  break;
-               }
-               default:
-               {
-                  var normal = this .getPolygonNormal (vertices, coordIndex, coord);
-                  break;
-               }
+               var normal = coord .getNormal (coordIndex [vertices [0]],
+                                                coordIndex [vertices [1]],
+                                                coordIndex [vertices [2]]);
+               break;
             }
-
-            // Add a normal index for each point.
-
-            for (let i = 0; i < length; ++ i)
+            case 4:
             {
-               const
-                  index = vertices [i],
-                  point = coordIndex [index];
+               var normal = coord .getQuadNormal (coordIndex [vertices [0]],
+                                                   coordIndex [vertices [1]],
+                                                   coordIndex [vertices [2]],
+                                                   coordIndex [vertices [3]]);
+               break;
+            }
+            default:
+            {
+               var normal = this .getPolygonNormal (vertices, coordIndex, coord);
+               break;
+            }
+         }
 
-               let pointNormals = normalIndex [point];
+         // Add a normal index for each point.
 
-               if (!pointNormals)
-                  pointNormals = normalIndex [point] = [ ];
+         for (const index of vertices)
+         {
+            const point = coordIndex [index];
 
-               pointNormals .push (index);
-            }
+            let pointNormals = normalIndex .get (point);
 
-            if (cw)
-               normal .negate ();
+            if (!pointNormals)
+               normalIndex .set (point, pointNormals = [ ]);
 
-            // Add this normal for each vertex.
+            pointNormals .push (index);
 
-            for (let i = 0; i < length; ++ i)
-               normals [vertices [i]] = normal;
+            normals [index] = normal;
          }
 
-         return this .refineNormals (normalIndex, normals, this ._creaseAngle .getValue ());
-      };
-   })(),
+         if (cw)
+            normal .negate ();
+      }
+
+      // if (!this ._normalPerVertex .getValue ())
+      //    return normals;
+
+      return this .refineNormals (normalIndex, normals, this ._creaseAngle .getValue ());
+   },
    getPolygonNormal: (() =>
    {
       let

package/src/x_ite/Components/Geospatial/GeoElevationGrid.js

@@ -136,16 +136,16 @@ Object .assign (Object .setPrototypeOf (GeoElevationGrid .prototype, X3DGeometry
    },
    createTexCoords ()
    {
-      var
+      const
          texCoords  = [ ],
          xDimension = this ._xDimension .getValue (),
          zDimension = this ._zDimension .getValue (),
          xSize      = xDimension - 1,
          zSize      = zDimension - 1;
 
-      for (var z = 0; z < zDimension; ++ z)
+      for (let z = 0; z < zDimension; ++ z)
       {
-         for (var x = 0; x < xDimension; ++ x)
+         for (let x = 0; x < xDimension; ++ x)
             texCoords .push (new Vector2 (x / xSize, z / zSize));
       }
 
@@ -153,26 +153,26 @@ Object .assign (Object .setPrototypeOf (GeoElevationGrid .prototype, X3DGeometry
    },
    createNormals (points, coordIndex, creaseAngle)
    {
-      var
-         cw          = ! this ._ccw .getValue (),
-         normalIndex = [ ],
+      const
+         cw          = !this ._ccw .getValue (),
+         normalIndex = new Map (),
          normals     = [ ];
 
-      for (var p = 0; p < points .length; ++ p)
-         normalIndex [p] = [ ];
+      for (let p = 0; p < points .length; ++ p)
+         normalIndex .set (p, [ ]);
 
-      for (var c = 0; c < coordIndex .length; c += 3)
+      for (let c = 0; c < coordIndex .length; c += 3)
       {
-         var
+         const
             c0 = coordIndex [c],
             c1 = coordIndex [c + 1],
             c2 = coordIndex [c + 2];
 
-         normalIndex [c0] .push (normals .length);
-         normalIndex [c1] .push (normals .length + 1);
-         normalIndex [c2] .push (normals .length + 2);
+         normalIndex .get (c0) .push (normals .length);
+         normalIndex .get (c1) .push (normals .length + 1);
+         normalIndex .get (c2) .push (normals .length + 2);
 
-         var normal = Triangle3 .normal (points [c0], points [c1], points [c2], new Vector3 (0, 0, 0));
+         const normal = Triangle3 .normal (points [c0], points [c1], points [c2], new Vector3 (0, 0, 0));
 
          if (cw)
             normal .negate ();
@@ -182,6 +182,9 @@ Object .assign (Object .setPrototypeOf (GeoElevationGrid .prototype, X3DGeometry
          normals .push (normal);
       }
 
+      // if (!this ._normalPerVertex .getValue ())
+      //    return normals;
+
       return this .refineNormals (normalIndex, normals, this ._creaseAngle .getValue ());
    },
    createCoordIndex ()
@@ -190,18 +193,18 @@ Object .assign (Object .setPrototypeOf (GeoElevationGrid .prototype, X3DGeometry
       //  | \ |
       // p2 - p3
 
-      var
+      const
          coordIndex = [ ],
          xDimension = this ._xDimension .getValue (),
          zDimension = this ._zDimension .getValue (),
          xSize      = xDimension - 1,
          zSize      = zDimension - 1;
 
-      for (var z = 0; z < zSize; ++ z)
+      for (let z = 0; z < zSize; ++ z)
       {
-         for (var x = 0; x < xSize; ++ x)
+         for (let x = 0; x < xSize; ++ x)
          {
-            var
+            const
                i1 =       z * xDimension + x,
                i2 = (z + 1) * xDimension + x,
                i3 = (z + 1) * xDimension + (x + 1),
@@ -221,7 +224,7 @@ Object .assign (Object .setPrototypeOf (GeoElevationGrid .prototype, X3DGeometry
    },
    createPoints ()
    {
-      var
+      const
          points     = [ ],
          xDimension = this ._xDimension .getValue (),
          zDimension = this ._zDimension .getValue (),
@@ -237,13 +240,13 @@ Object .assign (Object .setPrototypeOf (GeoElevationGrid .prototype, X3DGeometry
 
       if (this .getStandardOrder ())
       {
-         for (var z = 0; z < zDimension; ++ z)
+         for (let z = 0; z < zDimension; ++ z)
          {
-            for (var x = 0; x < xDimension; ++ x)
+            for (let x = 0; x < xDimension; ++ x)
             {
-               var point = new Vector3 (zSpacing * z, // latitude, northing
-                                        xSpacing * x, // longitude, easting
-                                        this .getHeight (x + z * xDimension));
+               const point = new Vector3 (zSpacing * z, // latitude, northing
+                                          xSpacing * x, // longitude, easting
+                                          this .getHeight (x + z * xDimension));
 
                point .add (this ._geoGridOrigin .getValue ());
 
@@ -253,13 +256,13 @@ Object .assign (Object .setPrototypeOf (GeoElevationGrid .prototype, X3DGeometry
       }
       else
       {
-         for (var z = 0; z < zDimension; ++ z)
+         for (let z = 0; z < zDimension; ++ z)
          {
-            for (var x = 0; x < xDimension; ++ x)
+            for (let x = 0; x < xDimension; ++ x)
             {
-               var point = new Vector3 (xSpacing * x, // longitude, easting
-                                        zSpacing * z, // latitude, northing
-                                        this .getHeight (x + z * xDimension));
+               const point = new Vector3 (xSpacing * x, // longitude, easting
+                                          zSpacing * z, // latitude, northing
+                                          this .getHeight (x + z * xDimension));
 
                point .add (this ._geoGridOrigin .getValue ());
 
@@ -275,7 +278,7 @@ Object .assign (Object .setPrototypeOf (GeoElevationGrid .prototype, X3DGeometry
       if (this ._xDimension .getValue () < 2 || this ._zDimension .getValue () < 2)
          return;
 
-      var
+      const
          colorPerVertex     = this ._colorPerVertex .getValue (),
          normalPerVertex    = this ._normalPerVertex .getValue (),
          coordIndex         = this .createCoordIndex (),
@@ -286,8 +289,9 @@ Object .assign (Object .setPrototypeOf (GeoElevationGrid .prototype, X3DGeometry
          colorArray         = this .getColors (),
          multiTexCoordArray = this .getMultiTexCoords (),
          normalArray        = this .getNormals (),
-         vertexArray        = this .getVertices (),
-         face               = 0;
+         vertexArray        = this .getVertices ();
+
+      let face = 0;
 
       // Vertex attribute
 
@@ -311,11 +315,11 @@ Object .assign (Object .setPrototypeOf (GeoElevationGrid .prototype, X3DGeometry
 
       // Build geometry
 
-      for (var c = 0; c < coordIndex .length; ++ face)
+      for (let c = 0; c < coordIndex .length; ++ face)
       {
-         for (var p = 0; p < 6; ++ p, ++ c)
+         for (let p = 0; p < 6; ++ p, ++ c)
          {
-            var
+            const
                index = coordIndex [c],
                point = points [index];
 
@@ -336,7 +340,7 @@ Object .assign (Object .setPrototypeOf (GeoElevationGrid .prototype, X3DGeometry
             }
             else
             {
-               var t = texCoords [index];
+               const t = texCoords [index];
 
                texCoordArray .push (t .x, t .y, 0, 1);
             }
@@ -356,13 +360,13 @@ Object .assign (Object .setPrototypeOf (GeoElevationGrid .prototype, X3DGeometry
 
       // Add auto-generated normals if needed.
 
-      if (! normalNode)
+      if (!normalNode)
       {
-         var normals = this .createNormals (points, coordIndex);
+         const normals = this .createNormals (points, coordIndex);
 
-         for (var i = 0; i < normals .length; ++ i)
+         for (let i = 0; i < normals .length; ++ i)
          {
-            var normal = normals [i];
+            const normal = normals [i];
 
             normalArray .push (normal .x, normal .y, normal .z);
          }

package/src/x_ite/Components/NURBS/X3DNurbsSurfaceGeometryNode.js

@@ -165,7 +165,7 @@ Object .assign (Object .setPrototypeOf (X3DNurbsSurfaceGeometryNode .prototype,
       if (this ._vDimension .getValue () < this ._vOrder .getValue ())
          return;
 
-      if (! this .controlPointNode)
+      if (!this .controlPointNode)
          return;
 
       if (this .controlPointNode .getSize () !== this ._uDimension .getValue () * this ._vDimension .getValue ())
@@ -320,17 +320,18 @@ Object .assign (Object .setPrototypeOf (X3DNurbsSurfaceGeometryNode .prototype,
    createNormals (faces, points)
    {
       const
+         normalIndex = new Map (),
          normals     = this .createFaceNormals (faces, points),
-         normalIndex = [ ];
+         length      = faces .length;
 
-      for (let i = 0, length = faces .length; i < length; ++ i)
+      for (let i = 0; i < length; ++ i)
       {
          const index = faces [i];
 
-         let pointIndex = normalIndex [index];
+         let pointIndex = normalIndex .get (index);
 
-         if (! pointIndex)
-            pointIndex = normalIndex [index] = [ ];
+         if (!pointIndex)
+            normalIndex .set (index, pointIndex = [ ]);
 
          pointIndex .push (i);
       }

package/src/x_ite/Components/Rendering/X3DComposedGeometryNode.js

@@ -271,26 +271,24 @@ Object .assign (Object .setPrototypeOf (X3DComposedGeometryNode .prototype, X3DG
    {
       const normals = this .createFaceNormals (verticesPerPolygon, polygonsSize);
 
-      if (this ._normalPerVertex .getValue ())
-      {
-         const normalIndex = [ ];
+      if (!this ._normalPerVertex .getValue ())
+         return normals;
 
-         for (let i = 0; i < polygonsSize; ++ i)
-         {
-            const index = this .getPolygonIndex (i);
+      const normalIndex = new Map ();
 
-            let pointIndex = normalIndex [index];
+      for (let i = 0; i < polygonsSize; ++ i)
+      {
+         const index = this .getPolygonIndex (i);
 
-            if (!pointIndex)
-               pointIndex = normalIndex [index] = [ ];
+         let pointIndex = normalIndex .get (index);
 
-            pointIndex .push (i);
-         }
+         if (!pointIndex)
+            normalIndex .set (index, pointIndex = [ ]);
 
-         return this .refineNormals (normalIndex, normals, Math .PI);
+         pointIndex .push (i);
       }
 
-      return normals;
+      return this .refineNormals (normalIndex, normals, Math .PI);
    },
    createFaceNormals (verticesPerPolygon, polygonsSize)
    {

package/src/x_ite/Components/Rendering/X3DGeometryNode.js

@@ -441,12 +441,10 @@ Object .assign (Object .setPrototypeOf (X3DGeometryNode .prototype, X3DNode .pro
 
       const
          cosCreaseAngle = Math .cos (Algorithm .clamp (creaseAngle, 0, Math .PI)),
-         normals_       = [ ];
+         refinedNormals = [ ];
 
-      for (const i in normalIndex) // Don't use forEach
+      for (const vertex of normalIndex .values ())
       {
-         const vertex = normalIndex [i];
-
          for (const p of vertex)
          {
             const
@@ -461,11 +459,11 @@ Object .assign (Object .setPrototypeOf (X3DGeometryNode .prototype, X3DNode .pro
                   N .add (Q);
             }
 
-            normals_ [p] = N .normalize ();
+            refinedNormals [p] = N .normalize ();
          }
       }
 
-      return normals_;
+      return refinedNormals;
    },
    transformLine (hitRay)
    {

package/src/x_ite/Components/Scripting/Script.js

@@ -167,7 +167,7 @@ Object .assign (Object .setPrototypeOf (Script .prototype, X3DScriptNode .protot
             }
          }
 
-         sourceText += "\n[" + callbacks .map (c => `typeof ${c} !== "undefined" ? ${c} : undefined`) .join (",") + "];";
+         sourceText += ";\n[" + callbacks .map (c => `typeof ${c} !== "undefined" ? ${c} : undefined`) .join (",") + "];";
 
          this .globalObject = this .getGlobalObject ();
 

package/src/x_ite/Parser/GLTF2Parser.js

@@ -85,13 +85,13 @@ function GLTF2Parser (scene)
    this .samplers              = [ ];
    this .materials             = [ ];
    this .textureTransformNodes = [ ];
+   this .meshes                = [ ];
    this .cameras               = [ ];
    this .viewpoints            = 0;
    this .nodes                 = [ ];
    this .skins                 = [ ];
    this .joints                = new Set ();
    this .skeletons             = new Set ();
-   this .inverseBindMatrices   = new Map ();
    this .animations            = 0;
 }
 
@@ -1486,9 +1486,9 @@ Object .assign (Object .setPrototypeOf (GLTF2Parser .prototype, X3DParser .proto
             if (skeletonNode)
                humanoidNode ._skeleton .push (skeletonNode);
 
-            for (const joint of skin .joints)
+            for (const [i, joint] of skin .joints .entries ())
             {
-               const inverseBindMatrix = this .inverseBindMatrices .get (joint);
+               const inverseBindMatrix = skin .inverseBindMatrices [i] ?? Matrix4 .Identity;
 
                inverseBindMatrix .get (translation, rotation, scale);
 
@@ -1577,7 +1577,7 @@ Object .assign (Object .setPrototypeOf (GLTF2Parser .prototype, X3DParser .proto
 
       this .skeletons .add (skin .skeleton);
 
-      this .inverseBindMatricesAccessors (this .accessors [skin .inverseBindMatrices], skin .joints);
+      skin .inverseBindMatrices = this .inverseBindMatricesAccessors (this .accessors [skin .inverseBindMatrices]);
    },
    jointsArray: function (joints)
    {
@@ -1598,10 +1598,10 @@ Object .assign (Object .setPrototypeOf (GLTF2Parser .prototype, X3DParser .proto
 
       return joints .filter (index => !children .has (index)) [0];
    },
-   inverseBindMatricesAccessors: function (inverseBindMatrices, joints)
+   inverseBindMatricesAccessors: function (inverseBindMatrices)
    {
       if (!inverseBindMatrices)
-         return;
+         return [ ];
 
       const
          array    = inverseBindMatrices .array,
@@ -1611,7 +1611,7 @@ Object .assign (Object .setPrototypeOf (GLTF2Parser .prototype, X3DParser .proto
       for (let i = 0; i < length; i += 16)
          matrices .push (new Matrix4 (... array .subarray (i, i + 16)));
 
-      matrices .forEach ((matrix, i) => this .inverseBindMatrices .set (joints [i], matrix));
+      return matrices;
    },
    scenesArray (scenes, sceneNumber)
    {