x_ite 5.0.2 → 6.0.0

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

@@ -226,105 +226,98 @@ function (Fields,
 
          return function (layerNode, fromViewpointNode, toViewpointNode)
          {
-            try
-            {
-               this .to = toViewpointNode;
+            this .to = toViewpointNode;
 
-               if (toViewpointNode ._jump .getValue ())
-               {
-                  if (! toViewpointNode ._retainUserOffsets .getValue ())
-                     toViewpointNode .resetUserOffsets ();
+            if (toViewpointNode ._jump .getValue ())
+            {
+               if (! toViewpointNode ._retainUserOffsets .getValue ())
+                  toViewpointNode .resetUserOffsets ();
 
-                  // Copy from toViewpointNode all fields.
+               // Copy from toViewpointNode all fields.
 
-                  if (this !== toViewpointNode)
-                  {
-                     for (const field of toViewpointNode .getFields ())
-                        this .getField (field .getName ()) .assign (field);
-                  }
+               if (this !== toViewpointNode)
+               {
+                  for (const field of toViewpointNode .getFields ())
+                     this .getField (field .getName ()) .assign (field);
+               }
 
-                  // Respect NavigationInfo.
+               // Respect NavigationInfo.
 
-                  const
-                     navigationInfoNode = layerNode .getNavigationInfo (),
-                     transitionTime     = navigationInfoNode ._transitionTime .getValue ();
+               const
+                  navigationInfoNode = layerNode .getNavigationInfo (),
+                  transitionTime     = navigationInfoNode ._transitionTime .getValue ();
 
-                  let transitionType = navigationInfoNode .getTransitionType ();
+               let transitionType = navigationInfoNode .getTransitionType ();
 
-                  // VRML behavior
+               // VRML behavior
 
-                  if (this .getExecutionContext () .getSpecificationVersion () == "2.0")
-                  {
-                     if (toViewpointNode .getVRMLTransition ())
-                        transitionType = "LINEAR";
-                     else
-                        transitionType = "TELEPORT";
-                  }
+               if (this .getExecutionContext () .getSpecificationVersion () == "2.0")
+               {
+                  if (toViewpointNode .getVRMLTransition ())
+                     transitionType = "LINEAR";
+                  else
+                     transitionType = "TELEPORT";
+               }
 
-                  toViewpointNode .setVRMLTransition (false);
+               toViewpointNode .setVRMLTransition (false);
 
-                  // End VRML behavior
+               // End VRML behavior
 
-                  if (transitionTime <= 0)
-                     transitionType = "TELEPORT";
+               if (transitionTime <= 0)
+                  transitionType = "TELEPORT";
 
-                  switch (transitionType)
+               switch (transitionType)
+               {
+                  case "TELEPORT":
                   {
-                     case "TELEPORT":
-                     {
-                        navigationInfoNode ._transitionComplete = true;
-                        return;
-                     }
-                     case "ANIMATE":
-                     {
-                        this .easeInEaseOut ._easeInEaseOut = new Fields .MFVec2f (new Fields .SFVec2f (0, 1), new Fields .SFVec2f (1, 0));
-                        break;
-                     }
-                     default:
-                     {
-                        // LINEAR
-                        this .easeInEaseOut ._easeInEaseOut = new Fields .MFVec2f (new Fields .SFVec2f (0, 0), new Fields .SFVec2f (0, 0));
-                        break;
-                     }
+                     navigationInfoNode ._transitionComplete = true;
+                     return;
                   }
+                  case "ANIMATE":
+                  {
+                     this .easeInEaseOut ._easeInEaseOut = new Fields .MFVec2f (new Fields .SFVec2f (0, 1), new Fields .SFVec2f (1, 0));
+                     break;
+                  }
+                  default:
+                  {
+                     // LINEAR
+                     this .easeInEaseOut ._easeInEaseOut = new Fields .MFVec2f (new Fields .SFVec2f (0, 0), new Fields .SFVec2f (0, 0));
+                     break;
+                  }
+               }
 
-                  this .timeSensor ._cycleInterval = transitionTime;
-                  this .timeSensor ._stopTime      = this .getBrowser () .getCurrentTime ();
-                  this .timeSensor ._startTime     = this .getBrowser () .getCurrentTime ();
-
-                  this .timeSensor ._isActive .addInterest ("set_active__", this, navigationInfoNode);
-
-                  toViewpointNode .getRelativeTransformation (fromViewpointNode, relativePosition, relativeOrientation, relativeScale, relativeScaleOrientation);
+               this .timeSensor ._cycleInterval = transitionTime;
+               this .timeSensor ._stopTime      = this .getBrowser () .getCurrentTime ();
+               this .timeSensor ._startTime     = this .getBrowser () .getCurrentTime ();
 
-                  this .positionInterpolator         ._keyValue = new Fields .MFVec3f    (relativePosition,         toViewpointNode ._positionOffset);
-                  this .orientationInterpolator      ._keyValue = new Fields .MFRotation (relativeOrientation,      toViewpointNode ._orientationOffset);
-                  this .scaleInterpolator            ._keyValue = new Fields .MFVec3f    (relativeScale,            toViewpointNode ._scaleOffset);
-                  this .scaleOrientationInterpolator ._keyValue = new Fields .MFRotation (relativeScaleOrientation, toViewpointNode ._scaleOrientationOffset);
+               this .timeSensor ._isActive .addInterest ("set_active__", this, navigationInfoNode);
 
-                  this ._positionOffset         = relativePosition;
-                  this ._orientationOffset      = relativeOrientation;
-                  this ._scaleOffset            = relativeScale;
-                  this ._scaleOrientationOffset = relativeScaleOrientation;
+               toViewpointNode .getRelativeTransformation (fromViewpointNode, relativePosition, relativeOrientation, relativeScale, relativeScaleOrientation);
 
-                  this .setInterpolators (fromViewpointNode, toViewpointNode);
+               this .positionInterpolator         ._keyValue = new Fields .MFVec3f    (relativePosition,         toViewpointNode ._positionOffset);
+               this .orientationInterpolator      ._keyValue = new Fields .MFRotation (relativeOrientation,      toViewpointNode ._orientationOffset);
+               this .scaleInterpolator            ._keyValue = new Fields .MFVec3f    (relativeScale,            toViewpointNode ._scaleOffset);
+               this .scaleOrientationInterpolator ._keyValue = new Fields .MFRotation (relativeScaleOrientation, toViewpointNode ._scaleOrientationOffset);
 
-                  this ._transitionActive = true;
-               }
-               else
-               {
-                  toViewpointNode .getRelativeTransformation (fromViewpointNode, relativePosition, relativeOrientation, relativeScale, relativeScaleOrientation);
+               this ._positionOffset         = relativePosition;
+               this ._orientationOffset      = relativeOrientation;
+               this ._scaleOffset            = relativeScale;
+               this ._scaleOrientationOffset = relativeScaleOrientation;
 
-                  toViewpointNode ._positionOffset         = relativePosition;
-                  toViewpointNode ._orientationOffset      = relativeOrientation;
-                  toViewpointNode ._scaleOffset            = relativeScale;
-                  toViewpointNode ._scaleOrientationOffset = relativeScaleOrientation;
+               this .setInterpolators (fromViewpointNode, toViewpointNode);
 
-                  toViewpointNode .setInterpolators (fromViewpointNode, toViewpointNode);
-               }
+               this ._transitionActive = true;
             }
-            catch (error)
+            else
             {
-               console .error (error);
+               toViewpointNode .getRelativeTransformation (fromViewpointNode, relativePosition, relativeOrientation, relativeScale, relativeScaleOrientation);
+
+               toViewpointNode ._positionOffset         = relativePosition;
+               toViewpointNode ._orientationOffset      = relativeOrientation;
+               toViewpointNode ._scaleOffset            = relativeScale;
+               toViewpointNode ._scaleOrientationOffset = relativeScaleOrientation;
+
+               toViewpointNode .setInterpolators (fromViewpointNode, toViewpointNode);
             }
          };
       })(),
@@ -343,7 +336,6 @@ function (Fields,
          this ._fieldOfViewScale       = 1;
       },
       getRelativeTransformation: function (fromViewpointNode, relativePosition, relativeOrientation, relativeScale, relativeScaleOrientation)
-      // throw
       {
          const differenceMatrix = this .modelMatrix .copy () .multRight (fromViewpointNode .getViewMatrix ()) .inverse ();
 
@@ -354,35 +346,21 @@ function (Fields,
       },
       lookAtPoint: function (layerNode, point, factor, straighten)
       {
-         try
-         {
-            this .getCameraSpaceMatrix () .multVecMatrix (point);
+         this .getCameraSpaceMatrix () .multVecMatrix (point);
 
-            Matrix4 .inverse (this .getModelMatrix ()) .multVecMatrix (point);
+         Matrix4 .inverse (this .getModelMatrix ()) .multVecMatrix (point);
 
-            const minDistance = layerNode .getNavigationInfo () .getNearValue () * 2;
+         const minDistance = layerNode .getNavigationInfo () .getNearValue () * 2;
 
-            this .lookAt (layerNode, point, minDistance, factor, straighten);
-         }
-         catch (error)
-         {
-            console .error (error);
-         }
+         this .lookAt (layerNode, point, minDistance, factor, straighten);
       },
       lookAtBBox: function (layerNode, bbox, factor, straighten)
       {
-         try
-         {
-            bbox = bbox .copy () .multRight (Matrix4 .inverse (this .getModelMatrix ()));
+         bbox = bbox .copy () .multRight (Matrix4 .inverse (this .getModelMatrix ()));
 
-            const minDistance = layerNode .getNavigationInfo () .getNearValue () * 2;
+         const minDistance = layerNode .getNavigationInfo () .getNearValue () * 2;
 
-            this .lookAt (layerNode, bbox .center, minDistance, factor, straighten);
-         }
-         catch (error)
-         {
-            console .error (error);
-         }
+         this .lookAt (layerNode, bbox .center, minDistance, factor, straighten);
       },
       lookAt: function (layerNode, point, distance, factor, straighten)
       {
@@ -496,21 +474,14 @@ function (Fields,
       },
       update: function ()
       {
-         try
-         {
-            this .cameraSpaceMatrix .set (this .getUserPosition (),
-                                          this .getUserOrientation (),
-                                          this ._scaleOffset .getValue (),
-                                          this ._scaleOrientationOffset .getValue ());
+         this .cameraSpaceMatrix .set (this .getUserPosition (),
+                                       this .getUserOrientation (),
+                                       this ._scaleOffset .getValue (),
+                                       this ._scaleOrientationOffset .getValue ());
 
-            this .cameraSpaceMatrix .multRight ((this .to || this) .modelMatrix);
+         this .cameraSpaceMatrix .multRight ((this .to || this) .modelMatrix);
 
-            this .viewMatrix .assign (this .cameraSpaceMatrix) .inverse ();
-         }
-         catch (error)
-         {
-            console .error (error);
-         }
+         this .viewMatrix .assign (this .cameraSpaceMatrix) .inverse ();
       }
    });
 

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

@@ -183,20 +183,26 @@ function (Fields,
       {
          if (type === TraverseType .POINTER)
          {
-            const sensors = this .sensors;
+            const
+               sensorsStack = renderObject .getBrowser () .getSensors (),
+               sensors      = this .sensors;
 
             sensors .clear ();
 
-            renderObject .getBrowser () .getSensors () .push (sensors);
-
             this .touchSensorNode .push (renderObject, sensors);
 
+            if (sensors .size)
+               sensorsStack .push (sensors);
+
             X3DGroupingNode .prototype .traverse .call (this, type, renderObject);
 
-            renderObject .getBrowser () .getSensors () .pop ();
+            if (sensors .size)
+               sensorsStack .pop ();
          }
          else
+         {
             X3DGroupingNode .prototype .traverse .call (this, type, renderObject);
+         }
       },
    });
 

package/src/x_ite/Components/ParticleSystems/BoundedPhysicsModel.js

@@ -111,17 +111,17 @@ function (Fields,
       },
       addGeometry: function (boundedNormals, boundedVertices)
       {
-         if (this .geometryNode)
+         if (this .geometryNode && this ._enabled .getValue ())
          {
-            var
+            const
                normals  = this .geometryNode .getNormals ()  .getValue (),
                vertices = this .geometryNode .getVertices () .getValue ();
 
-            for (var i = 0, length = normals .length; i < length; ++ i)
-               boundedNormals .push (normals [i]);
+            for (const value of normals)
+               boundedNormals .push (value);
 
-            for (var i = 0, length = vertices .length; i < length; ++ i)
-               boundedVertices .push (vertices [i]);
+            for (const value of vertices)
+               boundedVertices .push (value);
          }
       },
    });

package/src/x_ite/Components/ParticleSystems/ConeEmitter.js

@@ -53,16 +53,12 @@ define ([
    "x_ite/Base/FieldDefinitionArray",
    "x_ite/Components/ParticleSystems/X3DParticleEmitterNode",
    "x_ite/Base/X3DConstants",
-   "standard/Math/Numbers/Vector3",
-   "standard/Math/Numbers/Rotation4",
 ],
 function (Fields,
           X3DFieldDefinition,
           FieldDefinitionArray,
           X3DParticleEmitterNode,
-          X3DConstants,
-          Vector3,
-          Rotation4)
+          X3DConstants)
 {
 "use strict";
 
@@ -72,27 +68,47 @@ function (Fields,
 
       this .addType (X3DConstants .ConeEmitter);
 
-      this ._position    .setUnit ("length");
-      this ._angle       .setUnit ("angle");
-      this ._speed       .setUnit ("speed");
-      this ._mass        .setUnit ("mass");
-      this ._surfaceArea .setUnit ("area");
+      this ._position .setUnit ("length");
+      this ._angle    .setUnit ("angle");
 
-      this .rotation = new Rotation4 (0, 0, 1, 0);
+      this .addUniform ("position",  "uniform vec3  position;");
+      this .addUniform ("direction", "uniform vec3  direction;");
+      this .addUniform ("angle",     "uniform float angle;");
+
+      this .addFunction (/* glsl */ `vec3 getRandomVelocity ()
+      {
+         if (direction == vec3 (0.0))
+         {
+            return getRandomSphericalVelocity ();
+         }
+         else
+         {
+            vec3  normal = getRandomNormalWithDirectionAndAngle (direction, angle);
+            float speed  = getRandomSpeed ();
+
+            return normal * speed;
+         }
+      }`);
+
+      this .addFunction (/* glsl */ `vec4 getRandomPosition ()
+      {
+         return vec4 (position, 1.0);
+      }`);
    }
 
    ConeEmitter .prototype = Object .assign (Object .create (X3DParticleEmitterNode .prototype),
    {
       constructor: ConeEmitter,
       [Symbol .for ("X_ITE.X3DBaseNode.fieldDefinitions")]: new FieldDefinitionArray ([
-         new X3DFieldDefinition (X3DConstants .inputOutput,    "metadata",    new Fields .SFNode ()),
-         new X3DFieldDefinition (X3DConstants .inputOutput,    "position",    new Fields .SFVec3f ()),
-         new X3DFieldDefinition (X3DConstants .inputOutput,    "direction",   new Fields .SFVec3f (0, 1, 0)),
-         new X3DFieldDefinition (X3DConstants .inputOutput,    "angle",       new Fields .SFFloat (0.7854)),
-         new X3DFieldDefinition (X3DConstants .inputOutput,    "speed",       new Fields .SFFloat ()),
-         new X3DFieldDefinition (X3DConstants .inputOutput,    "variation",   new Fields .SFFloat (0.25)),
-         new X3DFieldDefinition (X3DConstants .initializeOnly, "mass",        new Fields .SFFloat ()),
-         new X3DFieldDefinition (X3DConstants .initializeOnly, "surfaceArea", new Fields .SFFloat ()),
+         new X3DFieldDefinition (X3DConstants .inputOutput, "metadata",    new Fields .SFNode ()),
+         new X3DFieldDefinition (X3DConstants .inputOutput, "on",          new Fields .SFBool (true)),
+         new X3DFieldDefinition (X3DConstants .inputOutput, "position",    new Fields .SFVec3f ()),
+         new X3DFieldDefinition (X3DConstants .inputOutput, "direction",   new Fields .SFVec3f (0, 1, 0)),
+         new X3DFieldDefinition (X3DConstants .inputOutput, "angle",       new Fields .SFFloat (0.7854)),
+         new X3DFieldDefinition (X3DConstants .inputOutput, "speed",       new Fields .SFFloat ()),
+         new X3DFieldDefinition (X3DConstants .inputOutput, "variation",   new Fields .SFFloat (0.25)),
+         new X3DFieldDefinition (X3DConstants .inputOutput, "mass",        new Fields .SFFloat ()),
+         new X3DFieldDefinition (X3DConstants .inputOutput, "surfaceArea", new Fields .SFFloat ()),
       ]),
       getTypeName: function ()
       {
@@ -110,6 +126,9 @@ function (Fields,
       {
          X3DParticleEmitterNode .prototype .initialize .call (this);
 
+         if (this .getBrowser () .getContext () .getVersion () < 2)
+            return;
+
          this ._position  .addInterest ("set_position__", this);
          this ._direction .addInterest ("set_direction__", this);
          this ._angle     .addInterest ("set_angle__", this);
@@ -120,31 +139,20 @@ function (Fields,
       },
       set_position__: function ()
       {
-         this .position = this ._position .getValue ()
+         const position = this ._position .getValue ();
+
+         this .setUniform ("uniform3f", "position", position .x, position .y, position .z);
       },
       set_direction__: function ()
       {
-         var direction = this ._direction .getValue ();
-
-         this .rotation .setFromToVec (Vector3 .zAxis, direction);
+         const direction = this ._direction .getValue ();
 
-         if (direction .equals (Vector3 .Zero))
-            this .getRandomVelocity = this .getSphericalRandomVelocity;
-         else
-            delete this .getRandomVelocity;
+         this .setUniform ("uniform3f", "direction", direction .x, direction .y, direction .z);
       },
       set_angle__: function ()
       {
-         this .angle = this ._angle .getValue ()
+         this .setUniform ("uniform1f", "angle", this ._angle .getValue ());
       },
-      getRandomPosition: function (position)
-      {
-         return position .assign (this .position);
-      },
-      getRandomVelocity: function (velocity)
-      {
-         return this .rotation .multVecRot (this .getRandomNormalWithAngle (this .angle, velocity) .multiply (this .getRandomSpeed ()));
-       },
    });
 
    return ConeEmitter;

package/src/x_ite/Components/ParticleSystems/ExplosionEmitter.js

@@ -68,24 +68,32 @@ function (Fields,
 
       this .addType (X3DConstants .ExplosionEmitter);
 
-      this ._position    .setUnit ("length");
-      this ._speed       .setUnit ("speed");
-      this ._mass        .setUnit ("mass");
-      this ._surfaceArea .setUnit ("area");
+      this ._position .setUnit ("length");
 
-      this .getRandomVelocity = this .getSphericalRandomVelocity;
+      this .addUniform ("position", "uniform vec3 position;");
+
+      this .addFunction (/* glsl */ `vec3 getRandomVelocity ()
+      {
+         return getRandomSphericalVelocity ();
+      }`);
+
+      this .addFunction (/* glsl */ `vec4 getRandomPosition ()
+      {
+         return vec4 (position, 1.0);
+      }`);
    }
 
    ExplosionEmitter .prototype = Object .assign (Object .create (X3DParticleEmitterNode .prototype),
    {
       constructor: ExplosionEmitter,
       [Symbol .for ("X_ITE.X3DBaseNode.fieldDefinitions")]: new FieldDefinitionArray ([
-         new X3DFieldDefinition (X3DConstants .inputOutput,    "metadata",    new Fields .SFNode ()),
-         new X3DFieldDefinition (X3DConstants .inputOutput,    "position",    new Fields .SFVec3f ()),
-         new X3DFieldDefinition (X3DConstants .inputOutput,    "speed",       new Fields .SFFloat ()),
-         new X3DFieldDefinition (X3DConstants .inputOutput,    "variation",   new Fields .SFFloat (0.25)),
-         new X3DFieldDefinition (X3DConstants .initializeOnly, "mass",        new Fields .SFFloat ()),
-         new X3DFieldDefinition (X3DConstants .initializeOnly, "surfaceArea", new Fields .SFFloat ()),
+         new X3DFieldDefinition (X3DConstants .inputOutput, "metadata",    new Fields .SFNode ()),
+         new X3DFieldDefinition (X3DConstants .inputOutput, "on",          new Fields .SFBool (true)),
+         new X3DFieldDefinition (X3DConstants .inputOutput, "position",    new Fields .SFVec3f ()),
+         new X3DFieldDefinition (X3DConstants .inputOutput, "speed",       new Fields .SFFloat ()),
+         new X3DFieldDefinition (X3DConstants .inputOutput, "variation",   new Fields .SFFloat (0.25)),
+         new X3DFieldDefinition (X3DConstants .inputOutput, "mass",        new Fields .SFFloat ()),
+         new X3DFieldDefinition (X3DConstants .inputOutput, "surfaceArea", new Fields .SFFloat ()),
       ]),
       getTypeName: function ()
       {
@@ -103,21 +111,22 @@ function (Fields,
       {
          X3DParticleEmitterNode .prototype .initialize .call (this);
 
+         if (this .getBrowser () .getContext () .getVersion () < 2)
+            return;
+
          this ._position .addInterest ("set_position__", this);
 
          this .set_position__ ();
       },
-      set_position__: function ()
-      {
-         this .position = this ._position .getValue ()
-      },
       isExplosive: function ()
       {
          return true;
       },
-      getRandomPosition: function (position)
+      set_position__: function ()
       {
-         return position .assign (this .position);
+         const position = this ._position .getValue ();
+
+         this .setUniform ("uniform3f", "position", position .x, position .y, position .z);
       },
    });
 

package/src/x_ite/Components/ParticleSystems/ForcePhysicsModel.js

@@ -53,12 +53,14 @@ define ([
    "x_ite/Base/FieldDefinitionArray",
    "x_ite/Components/ParticleSystems/X3DParticlePhysicsModelNode",
    "x_ite/Base/X3DConstants",
+   "standard/Math/Numbers/Vector3",
 ],
 function (Fields,
           X3DFieldDefinition,
           FieldDefinitionArray,
           X3DParticlePhysicsModelNode,
-          X3DConstants)
+          X3DConstants,
+          Vector3)
 {
 "use strict";
 
@@ -91,14 +93,25 @@ function (Fields,
       {
          return "physics";
       },
-      addForce: function (i, emitterNode, forces, turbulences)
+      addForce: (function ()
       {
-         if (this ._enabled .getValue ())
+         const force = new Vector3 (0, 0, 0);
+
+         return function (i, emitterNode, timeByMass, forces)
          {
-            forces      [i] .assign (this ._force .getValue ());
-            turbulences [i] = 0;
-         }
-      },
+            if (this ._enabled .getValue ())
+            {
+               forces .set (force .assign (this ._force .getValue ()) .multiply (timeByMass), i * 4);
+               forces [i * 4 + 3] = 0;
+
+               return true;
+            }
+            else
+            {
+               return false;
+            }
+        };
+      })(),
    });
 
    return ForcePhysicsModel;