x_ite 8.9.2 → 8.9.4

package/src/x_ite/Components/Core/X3DPrototypeInstance.js

@@ -88,25 +88,9 @@ Object .assign (Object .setPrototypeOf (X3DPrototypeInstance .prototype, X3DNode
    {
       this [_body] ?.dispose ();
 
-      const protoNode = this [_protoNode];
-
-      if (protoNode .isExternProto)
-      {
-         if (protoNode .checkLoadState () !== X3DConstants .COMPLETE_STATE)
-         {
-            this [_body] = null;
-
-            if (this .isInitialized ())
-               X3DChildObject .prototype .addEvent .call (this);
-
-            protoNode ._updateInstances .addInterest ("construct", this);
-            protoNode .requestImmediateLoad () .catch (Function .prototype);
-
-            return;
-         }
-      }
-
-      const proto = protoNode .getProtoDeclaration ();
+      const
+         protoNode = this [_protoNode],
+         proto     = protoNode .getProtoDeclaration ();
 
       // If there is a proto, the externproto is completely loaded.
 
@@ -249,7 +233,14 @@ Object .assign (Object .setPrototypeOf (X3DPrototypeInstance .prototype, X3DNode
 
       protoNode ._name_changed .addFieldInterest (this ._typeName_changed);
 
-      this .construct ();
+      if (protoNode .isExternProto && protoNode .checkLoadState () !== X3DConstants .COMPLETE_STATE)
+      {
+         protoNode ._updateInstances .addInterest ("construct", this);
+      }
+      else
+      {
+         this .construct ();
+      }
    },
    getBody ()
    {

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

@@ -196,11 +196,11 @@ Object .assign (Object .setPrototypeOf (ElevationGrid .prototype, X3DGeometryNod
    {
       const
          cw          = ! this ._ccw .getValue (),
-         normalIndex = [ ],
+         normalIndex = new Map (),
          normals     = [ ];
 
       for (let p = 0, length = points .length; p < length; ++ p)
-         normalIndex [p] = [ ];
+         normalIndex .set (p, [ ]);
 
       for (let c = 0, length = coordIndex .length; c < length; c += 3)
       {
@@ -209,9 +209,9 @@ Object .assign (Object .setPrototypeOf (ElevationGrid .prototype, X3DGeometryNod
             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);
 
          const normal = Triangle3 .normal (points [c0], points [c1], points [c2], new Vector3 (0, 0, 0));
 
@@ -223,6 +223,9 @@ Object .assign (Object .setPrototypeOf (ElevationGrid .prototype, X3DGeometryNod
          normals .push (normal);
       }
 
+      // if (!this ._normalPerVertex .getValue ())
+      //    return normals;
+
       return this .refineNormals (normalIndex, normals, this ._creaseAngle .getValue ());
    },
    createCoordIndex ()

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/Networking/X3DUrlObject.js

@@ -45,9 +45,8 @@
  *
  ******************************************************************************/
 
-import Fields              from "../../Fields.js";
-import X3DConstants        from "../../Base/X3DConstants.js";
-import X3DProtoDeclaration from "../../Prototype/X3DProtoDeclaration.js";
+import Fields       from "../../Fields.js";
+import X3DConstants from "../../Base/X3DConstants.js";
 
 const
    _cache                   = Symbol (),

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/RigidBodyPhysics/BallJoint.js

@@ -62,7 +62,7 @@ function BallJoint (executionContext)
    this ._anchorPoint .setUnit ("length");
 
    this .joint             = null;
-   this .outputs           = { };
+   this .outputs           = new Set ();
    this .localAnchorPoint1 = new Vector3 (0, 0, 0);
    this .localAnchorPoint2 = new Vector3 (0, 0, 0);
 }
@@ -114,8 +114,7 @@ Object .assign (Object .setPrototypeOf (BallJoint .prototype, X3DRigidJointNode
    },
    set_forceOutput__ ()
    {
-      for (var key in this .outputs)
-         delete this .outputs [key];
+      this .outputs .clear ();
 
       for (var i = 0, length = this ._forceOutput .length; i < length; ++ i)
       {
@@ -123,16 +122,16 @@ Object .assign (Object .setPrototypeOf (BallJoint .prototype, X3DRigidJointNode
 
          if (value == "ALL")
          {
-            this .outputs .body1AnchorPoint = true;
-            this .outputs .body2AnchorPoint = true;
+            this .outputs .add ("body1AnchorPoint");
+            this .outputs .add ("body2AnchorPoint");
          }
          else
          {
-            this .outputs [value] = true;
+            this .outputs .add (value);
          }
       }
 
-      this .setOutput (!$.isEmptyObject (this .outputs));
+      this .setOutput (!! this .outputs .size);
    },
    set_anchorPoint__ ()
    {
@@ -155,7 +154,7 @@ Object .assign (Object .setPrototypeOf (BallJoint .prototype, X3DRigidJointNode
 
       return function ()
       {
-         if (this .outputs .body1AnchorPoint)
+         if (this .outputs .has ("body1AnchorPoint"))
             this ._body1AnchorPoint = this .getBody1 () .getMatrix () .multVecMatrix (this .getInitialInverseMatrix1 () .multVecMatrix (localAnchorPoint1 .assign (this .localAnchorPoint1)));
       };
    })(),
@@ -165,7 +164,7 @@ Object .assign (Object .setPrototypeOf (BallJoint .prototype, X3DRigidJointNode
 
       return function ()
       {
-         if (this .outputs .body2AnchorPoint)
+         if (this .outputs .has ("body2AnchorPoint"))
             this ._body2AnchorPoint = this .getBody2 () .getMatrix () .multVecMatrix (this .getInitialInverseMatrix2 () .multVecMatrix (localAnchorPoint2 .assign (this .localAnchorPoint2)));
       };
    })(),