x_ite 8.9.6 → 8.10.1

package/src/x_ite/Components/HAnim/HAnimJoint.js

@@ -53,6 +53,7 @@ import TraverseType         from "../../Rendering/TraverseType.js";
 import X3DConstants         from "../../Base/X3DConstants.js";
 import X3DCast              from "../../Base/X3DCast.js";
 import Matrix4              from "../../../standard/Math/Numbers/Matrix4.js";
+import Vector3              from "../../../standard/Math/Numbers/Vector3.js";
 
 function HAnimJoint (executionContext)
 {
@@ -60,12 +61,15 @@ function HAnimJoint (executionContext)
 
    this .addType (X3DConstants .HAnimJoint);
 
+   this .addChildObjects (X3DConstants .outputOnly, "displacements",       new Fields .SFTime (),
+                          X3DConstants .outputOnly, "displacementWeights", new Fields .SFTime ());
+
    this .setAllowedTypes (X3DConstants .HAnimJoint,
                           X3DConstants .HAnimSegment,
                           X3DConstants .HAnimSite);
 
-   this .displacerNodes = [ ];
-   this .modelMatrix    = new Matrix4 ();
+   this .displacerNodes  = [ ];
+   this .modelViewMatrix = new Matrix4 ();
 }
 
 Object .assign (Object .setPrototypeOf (HAnimJoint .prototype, X3DTransformNode .prototype),
@@ -74,31 +78,30 @@ Object .assign (Object .setPrototypeOf (HAnimJoint .prototype, X3DTransformNode
    {
       X3DTransformNode .prototype .initialize .call (this);
 
-      this ._skinCoordIndex .addInterest ("set_skinCoordIndex__", this);
-      this ._displacers     .addInterest ("set_displacers__",     this);
+      this ._displacers .addInterest ("set_displacers__", this);
 
       this .set_displacers__ ();
    },
-   setCameraObject (value)
-   {
-      X3DTransformNode .prototype .setCameraObject .call (this, value || !! this ._skinCoordIndex .length);
-   },
-   getModelMatrix ()
+   getModelViewMatrix ()
    {
-      return this .modelMatrix;
+      return this .modelViewMatrix;
    },
    getDisplacers ()
    {
       return this .displacerNodes;
    },
-   set_skinCoordIndex__ ()
-   {
-      this .set_cameraObjects__ ();
-   },
    set_displacers__ ()
    {
       const displacerNodes = this .displacerNodes;
 
+      for (const displacerNode of displacerNodes)
+      {
+         displacerNode ._coordIndex    .removeInterest ("addEvent", this ._displacements);
+         displacerNode ._displacements .removeInterest ("addEvent", this ._displacements);
+         displacerNode ._coordIndex    .removeInterest ("addEvent", this ._displacementWeights);
+         displacerNode ._weight        .removeInterest ("addEvent", this ._displacementWeights);
+      }
+
       displacerNodes .length = 0;
 
       for (const node of this ._displacers)
@@ -108,24 +111,33 @@ Object .assign (Object .setPrototypeOf (HAnimJoint .prototype, X3DTransformNode
          if (displacerNode)
             displacerNodes .push (displacerNode);
       }
+
+      for (const displacerNode of displacerNodes)
+      {
+         displacerNode ._coordIndex    .addInterest ("addEvent", this ._displacements);
+         displacerNode ._displacements .addInterest ("addEvent", this ._displacements);
+         displacerNode ._coordIndex    .addInterest ("addEvent", this ._displacementWeights);
+         displacerNode ._weight        .addInterest ("addEvent", this ._displacementWeights);
+      }
    },
    traverse (type, renderObject)
    {
-      if (type === TraverseType .CAMERA)
-      {
-         if (this ._skinCoordIndex .length)
-            this .modelMatrix .assign (this .getMatrix ()) .multRight (renderObject .getModelViewMatrix () .get ());
-      }
+      const modelViewMatrix = renderObject .getModelViewMatrix ();
+
+      modelViewMatrix .push ();
+      modelViewMatrix .multLeft (this .getMatrix ());
+
+      if (type === TraverseType .DISPLAY)
+         this .modelViewMatrix .assign (modelViewMatrix .get ());
 
-      X3DTransformNode .prototype .traverse .call (this, type, renderObject);
+      X3DTransformNode .prototype .groupTraverse .call (this, type, renderObject);
+
+      modelViewMatrix .pop ();
    },
    groupTraverse (type, renderObject)
    {
-      if (type === TraverseType .CAMERA)
-      {
-         if (this ._skinCoordIndex .length)
-            this .modelMatrix .assign (renderObject .getModelViewMatrix () .get ());
-      }
+      if (type === TraverseType .DISPLAY)
+         this .modelViewMatrix .assign (renderObject .getModelViewMatrix () .get ());
 
       X3DTransformNode .prototype .groupTraverse .call (this, type, renderObject);
    },

package/src/x_ite/Components/Layering/X3DLayerNode.js

@@ -208,13 +208,13 @@ Object .assign (Object .setPrototypeOf (X3DLayerNode .prototype, X3DNode .protot
    {
       return this .collisionTime;
    },
-   viewAll (factor = 1, straighten = false)
+   viewAll (transitionTime = 1, factor = 1, straighten = false)
    {
       const
          viewpointNode = this .getViewpoint (),
          bbox          = this .getBBox (new Box3 ()) .multRight (viewpointNode .getModelMatrix () .copy () .inverse ());
 
-      viewpointNode .lookAt (this, bbox .center, viewpointNode .getLookAtDistance (bbox), factor, straighten);
+      viewpointNode .lookAt (this, bbox .center, viewpointNode .getLookAtDistance (bbox), transitionTime, factor, straighten);
    },
    straightenView ()
    {

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

@@ -63,7 +63,7 @@ function NurbsOrientationInterpolator (executionContext)
 
    this .addType (X3DConstants .NurbsOrientationInterpolator);
 
-   this .addChildObjects ("rebuild", new Fields .SFTime ());
+   this .addChildObjects (X3DConstants .inputOutput, "rebuild", new Fields .SFTime ());
 
    this .interpolator  = new OrientationInterpolator (executionContext);
    this .knots         = [ ];

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

@@ -61,7 +61,7 @@ function NurbsPositionInterpolator (executionContext)
 
    this .addType (X3DConstants .NurbsPositionInterpolator);
 
-   this .addChildObjects ("rebuild", new Fields .SFTime ());
+   this .addChildObjects (X3DConstants .inputOutput, "rebuild", new Fields .SFTime ());
 
    this .interpolator  = new PositionInterpolator (executionContext);
    this .knots         = [ ];

package/src/x_ite/Components/Navigation/NavigationInfo.js

@@ -65,10 +65,10 @@ function NavigationInfo (executionContext)
 
    this .addType (X3DConstants .NavigationInfo);
 
-   this .addChildObjects ("transitionStart",  new Fields .SFBool (),
-                          "transitionActive", new Fields .SFBool (),
-                          "availableViewers", new Fields .MFString (),
-                          "viewer",           new Fields .SFString ("EXAMINE"));
+   this .addChildObjects (X3DConstants .outputOnly, "transitionStart",  new Fields .SFBool (),
+                          X3DConstants .outputOnly, "transitionActive", new Fields .SFBool (),
+                          X3DConstants .outputOnly, "availableViewers", new Fields .MFString (),
+                          X3DConstants .outputOnly, "viewer",           new Fields .SFString ("EXAMINE"));
 
    this ._avatarSize      .setUnit ("length");
    this ._speed           .setUnit ("speed");

package/src/x_ite/Components/Navigation/OrthoViewpoint.js

@@ -61,7 +61,7 @@ function OrthoViewpoint (executionContext)
 
    this .addType (X3DConstants .OrthoViewpoint);
 
-   this .addChildObjects ("fieldOfViewOffset", new Fields .MFFloat (0, 0, 0, 0));
+   this .addChildObjects (X3DConstants .inputOutput, "fieldOfViewOffset", new Fields .MFFloat (0, 0, 0, 0));
 
    this ._position         .setUnit ("length");
    this ._centerOfRotation .setUnit ("length");

package/src/x_ite/Components/Navigation/X3DViewpointNode.js

@@ -67,12 +67,12 @@ function X3DViewpointNode (executionContext)
 
    this .addType (X3DConstants .X3DViewpointNode);
 
-   this .addChildObjects ("positionOffset",         new Fields .SFVec3f (),
-                          "orientationOffset",      new Fields .SFRotation (),
-                          "scaleOffset",            new Fields .SFVec3f (1, 1, 1),
-                          "scaleOrientationOffset", new Fields .SFRotation (),
-                          "centerOfRotationOffset", new Fields .SFVec3f (),
-                          "fieldOfViewScale",       new Fields .SFFloat (1));
+   this .addChildObjects (X3DConstants .inputOutput, "positionOffset",         new Fields .SFVec3f (),
+                          X3DConstants .inputOutput, "orientationOffset",      new Fields .SFRotation (),
+                          X3DConstants .inputOutput, "scaleOffset",            new Fields .SFVec3f (1, 1, 1),
+                          X3DConstants .inputOutput, "scaleOrientationOffset", new Fields .SFRotation (),
+                          X3DConstants .inputOutput, "centerOfRotationOffset", new Fields .SFVec3f (),
+                          X3DConstants .inputOutput, "fieldOfViewScale",       new Fields .SFFloat (1));
 
    this .userPosition         = new Vector3 (0, 1, 0);
    this .userOrientation      = new Rotation4 ();
@@ -427,31 +427,31 @@ Object .assign (Object .setPrototypeOf (X3DViewpointNode .prototype, X3DBindable
          return r;
       };
    })(),
-   lookAtPoint (layerNode, point, factor, straighten)
+   lookAtPoint (layerNode, point, transitionTime = 1, factor = 1, straighten = false)
    {
       this .getCameraSpaceMatrix () .multVecMatrix (point);
       this .getModelMatrix () .copy () .inverse () .multVecMatrix (point);
 
       const minDistance = layerNode .getNavigationInfo () .getNearValue () * 2;
 
-      this .lookAt (layerNode, point, minDistance, factor, straighten);
+      this .lookAt (layerNode, point, minDistance, transitionTime = 1, factor = 1, straighten = false);
    },
-   lookAtBBox (layerNode, bbox, factor, straighten)
+   lookAtBBox (layerNode, bbox, transitionTime = 1, factor, straighten)
    {
       bbox = bbox .copy () .multRight (this .getModelMatrix () .copy () .inverse ());
 
       const minDistance = Math .max (layerNode .getNavigationInfo () .getNearValue () * 2, this .getLookAtDistance (bbox));
 
-      this .lookAt (layerNode, bbox .center, minDistance, factor, straighten);
+      this .lookAt (layerNode, bbox .center, minDistance, transitionTime, factor, straighten);
    },
-   lookAt (layerNode, point, distance, factor, straighten)
+   lookAt (layerNode, point, distance, transitionTime = 1, factor = 1, straighten = false)
    {
       const
          offset = point .copy () .add (this .getUserOrientation () .multVecRot (new Vector3 (0, 0, distance))) .subtract (this .getPosition ());
 
       layerNode .getNavigationInfo () ._transitionStart = true;
 
-      this .timeSensor ._cycleInterval = 1;
+      this .timeSensor ._cycleInterval = transitionTime;
       this .timeSensor ._stopTime      = this .getBrowser () .getCurrentTime ();
       this .timeSensor ._startTime     = this .getBrowser () .getCurrentTime ();
 

package/src/x_ite/Components/Networking/X3DUrlObject.js

@@ -58,8 +58,8 @@ function X3DUrlObject (executionContext)
 {
    this .addType (X3DConstants .X3DUrlObject);
 
-   this .addChildObjects ("loadState", new Fields .SFInt32 (X3DConstants .NOT_STARTED_STATE),
-                          "loadData",  new Fields .SFTime ());
+   this .addChildObjects (X3DConstants .outputOnly,  "loadState", new Fields .SFInt32 (X3DConstants .NOT_STARTED_STATE),
+                          X3DConstants .inputOutput, "loadData",  new Fields .SFTime ());
 
    this [_cache]                = true;
    this [_autoRefreshStartTime] = Date .now ();
@@ -149,16 +149,23 @@ Object .assign (X3DUrlObject .prototype,
 
          const loadState = this .checkLoadState ();
 
-         if (loadState === X3DConstants .COMPLETE_STATE)
+         switch (loadState)
          {
-            resolve ();
-            return;
-         }
-
-         if (loadState === X3DConstants .IN_PROGRESS_STATE)
-         {
-            loading ();
-            return;
+            case X3DConstants .IN_PROGRESS_STATE:
+            {
+               loading ();
+               return;
+            }
+            case X3DConstants .COMPLETE_STATE:
+            {
+               resolve ();
+               return;
+            }
+            case X3DConstants .FAILED_STATE:
+            {
+               reject ();
+               return;
+            }
          }
 
          if (!this ._load .getValue ())

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

@@ -202,20 +202,21 @@ Object .assign (Object .setPrototypeOf (IndexedLineSet .prototype, X3DLineGeomet
          return;
 
       const
-         coordIndex     = this ._coordIndex,
-         polylines      = this .getPolylineIndices (),
-         colorPerVertex = this ._colorPerVertex .getValue (),
-         attribNodes    = this .getAttrib (),
-         numAttribNodes = attribNodes .length,
-         attribArrays   = this .getAttribs (),
-         fogCoordNode   = this .fogCoordNode,
-         colorNode      = this .colorNode,
-         coordNode      = this .coordNode,
-         normalNode     = this .normalNode,
-         fogDepthArray  = this .getFogDepths (),
-         colorArray     = this .getColors (),
-         normalArray    = this .getNormals (),
-         vertexArray    = this .getVertices ();
+         coordIndex        = this ._coordIndex,
+         polylines         = this .getPolylineIndices (),
+         colorPerVertex    = this ._colorPerVertex .getValue (),
+         coordIndicesArray = this .getCoordIndices (),
+         attribNodes       = this .getAttrib (),
+         numAttribNodes    = attribNodes .length,
+         attribArrays      = this .getAttribs (),
+         fogCoordNode      = this .fogCoordNode,
+         colorNode         = this .colorNode,
+         coordNode         = this .coordNode,
+         normalNode        = this .normalNode,
+         fogDepthArray     = this .getFogDepths (),
+         colorArray        = this .getColors (),
+         normalArray       = this .getNormals (),
+         vertexArray       = this .getVertices ();
 
       // Fill GeometryNode
 
@@ -235,6 +236,8 @@ Object .assign (Object .setPrototypeOf (IndexedLineSet .prototype, X3DLineGeomet
                      i     = polyline [l],
                      index = coordIndex [i];
 
+                  coordIndicesArray .push (index);
+
                   for (let a = 0; a < numAttribNodes; ++ a)
                      attribNodes [a] .addValue (index, attribArrays [a]);
 

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

@@ -152,19 +152,20 @@ Object .assign (Object .setPrototypeOf (LineSet .prototype, X3DLineGeometryNode
       // Fill GeometryNode
 
       const
-         vertexCount    = this ._vertexCount,
-         attribNodes    = this .getAttrib (),
-         numAttribNodes = attribNodes .length,
-         attribArrays   = this .getAttribs (),
-         fogCoordNode   = this .fogCoordNode,
-         colorNode      = this .colorNode,
-         normalNode     = this .normalNode,
-         coordNode      = this .coordNode,
-         fogDepthArray  = this .getFogDepths (),
-         colorArray     = this .getColors (),
-         normalArray    = this .getNormals (),
-         vertexArray    = this .getVertices (),
-         size           = coordNode .getSize ();
+         vertexCount       = this ._vertexCount,
+         coordIndicesArray = this .getCoordIndices (),
+         attribNodes       = this .getAttrib (),
+         numAttribNodes    = attribNodes .length,
+         attribArrays      = this .getAttribs (),
+         fogCoordNode      = this .fogCoordNode,
+         colorNode         = this .colorNode,
+         normalNode        = this .normalNode,
+         coordNode         = this .coordNode,
+         fogDepthArray     = this .getFogDepths (),
+         colorArray        = this .getColors (),
+         normalArray       = this .getNormals (),
+         vertexArray       = this .getVertices (),
+         size              = coordNode .getSize ();
 
       let index = 0;
 
@@ -179,6 +180,8 @@ Object .assign (Object .setPrototypeOf (LineSet .prototype, X3DLineGeometryNode
 
             for (let i = 0; i < count; ++ i, index += i & 1)
             {
+               coordIndicesArray .push (index);
+
                for (let a = 0; a < numAttribNodes; ++ a)
                   attribNodes [a] .addValue (index, attribArrays [a]);
 

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

@@ -152,18 +152,22 @@ Object .assign (Object .setPrototypeOf (PointSet .prototype, X3DPointGeometryNod
          return;
 
       const
-         attribNodes    = this .getAttrib (),
-         numAttribNodes = attribNodes .length,
-         attribArrays   = this .getAttribs (),
-         fogCoordNode   = this .fogCoordNode,
-         fogDepthArray  = this .getFogDepths (),
-         colorNode      = this .colorNode,
-         colorArray     = this .getColors (),
-         coordNode      = this .coordNode,
-         normalArray    = this .getNormals (),
-         normalNode     = this .normalNode,
-         vertexArray    = this .getVertices (),
-         numPoints      = coordNode ._point .length;
+         coordIndicesArray = this .getCoordIndices (),
+         attribNodes       = this .getAttrib (),
+         numAttribNodes    = attribNodes .length,
+         attribArrays      = this .getAttribs (),
+         fogCoordNode      = this .fogCoordNode,
+         fogDepthArray     = this .getFogDepths (),
+         colorNode         = this .colorNode,
+         colorArray        = this .getColors (),
+         coordNode         = this .coordNode,
+         normalArray       = this .getNormals (),
+         normalNode        = this .normalNode,
+         vertexArray       = this .getVertices (),
+         numPoints         = coordNode ._point .length;
+
+      for (let i = 0; i < numPoints; ++ i)
+         coordIndicesArray .push (i);
 
       for (let a = 0; a < numAttribNodes; ++ a)
       {

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

@@ -55,9 +55,7 @@ function X3DColorNode (executionContext)
 
    this .addType (X3DConstants .X3DColorNode);
 
-   this .addChildObjects ("transparent", new Fields .SFBool ());
-
-   this ._transparent .setAccessType (X3DConstants .outputOnly);
+   this .addChildObjects (X3DConstants .outputOnly, "transparent", new Fields .SFBool ());
 }
 
 Object .assign (Object .setPrototypeOf (X3DColorNode .prototype, X3DGeometricPropertyNode .prototype),

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

@@ -196,6 +196,7 @@ Object .assign (Object .setPrototypeOf (X3DComposedGeometryNode .prototype, X3DG
       const
          colorPerVertex     = this ._colorPerVertex .getValue (),
          normalPerVertex    = this ._normalPerVertex .getValue (),
+         coordIndicesArray  = this .getCoordIndices (),
          attribNodes        = this .getAttrib (),
          numAttribNodes     = attribNodes .length,
          attribArrays       = this .getAttribs (),
@@ -220,6 +221,8 @@ Object .assign (Object .setPrototypeOf (X3DComposedGeometryNode .prototype, X3DG
             face  = Math .floor (i / verticesPerFace),
             index = this .getPolygonIndex (this .getTriangleIndex (i));
 
+         coordIndicesArray .push (index);
+
          for (let a = 0; a < numAttribNodes; ++ a)
             attribNodes [a] .addValue (index, attribArrays [a]);