x_ite 5.0.2 → 6.0.0

package/src/x_ite/Components/Shaders/X3DVertexAttributeNode.js

@@ -48,10 +48,12 @@
 
 
 define ([
+   "x_ite/Fields",
    "x_ite/Components/Rendering/X3DGeometricPropertyNode",
    "x_ite/Base/X3DConstants",
 ],
-function (X3DGeometricPropertyNode,
+function (Fields,
+          X3DGeometricPropertyNode,
           X3DConstants)
 {
 "use strict";
@@ -61,11 +63,31 @@ function (X3DGeometricPropertyNode,
       X3DGeometricPropertyNode .call (this, executionContext);
 
       this .addType (X3DConstants .X3DVertexAttributeNode);
+
+      this .addChildObjects ("attribute_changed", new Fields .SFTime ());
    }
 
    X3DVertexAttributeNode .prototype = Object .assign (Object .create (X3DGeometricPropertyNode .prototype),
    {
       constructor: X3DVertexAttributeNode,
+      initialize: function ()
+      {
+         X3DGeometricPropertyNode .prototype .initialize .call (this);
+
+         this ._name  .addInterest ("set_attribute__", this);
+         this ._value .addInterest ("set_value__",     this);
+
+         this .set_value__ ();
+      },
+      set_attribute__: function ()
+      {
+         this ._attribute_changed = this .getBrowser () .getCurrentTime ();
+      },
+      set_value__: function ()
+      {
+         this .value  = this ._value .getValue ();
+         this .length = this ._value .length;
+      },
    });
 
    return X3DVertexAttributeNode;

package/src/x_ite/Components/Shape/Appearance.js

@@ -154,6 +154,18 @@ function (Fields,
       {
          return this .alphaMode;
       },
+      getPointProperties: function ()
+      {
+         return this .stylePropertiesNode [0];
+      },
+      getLineProperties: function ()
+      {
+         return this .stylePropertiesNode [1];
+      },
+      getFillProperties: function ()
+      {
+         return this .stylePropertiesNode [2];
+      },
       set_live__: function ()
       {
          if (this .isLive () .getValue ())

package/src/x_ite/Components/Shape/FillProperties.js

@@ -104,10 +104,12 @@ function (Fields,
          this ._filled     .addInterest ("set_filled__",     this);
          this ._hatched    .addInterest ("set_hatched__",    this);
          this ._hatchColor .addInterest ("set_hatchColor__", this);
+         this ._hatchStyle .addInterest ("set_hatchStyle__", this);
 
          this .set_filled__ ();
          this .set_hatched__ ();
          this .set_hatchColor__ ();
+         this .set_hatchStyle__ ();
       },
       set_filled__: function ()
       {
@@ -125,6 +127,15 @@ function (Fields,
          this .hatchColor [1] = this ._hatchColor [1];
          this .hatchColor [2] = this ._hatchColor [2];
       },
+      set_hatchStyle__: function ()
+      {
+         let hatchStyle = this ._hatchStyle .getValue ();
+
+         if (hatchStyle < 1 || hatchStyle > 19)
+            hatchStyle = 1;
+
+         this .hatchStyle = hatchStyle;
+      },
       setTransparent: function (value)
       {
          if (value !== this ._transparent .getValue ())
@@ -145,7 +156,7 @@ function (Fields,
          {
             const
                browser     = shaderObject .getBrowser (),
-               texture     = browser .getHatchStyle (this ._hatchStyle .getValue ()),
+               texture     = browser .getHatchStyleTexture (this .hatchStyle),
                textureUnit = browser .getTexture2DUnit ();
 
             gl .uniform3fv (shaderObject .x3d_FillPropertiesHatchColor, this .hatchColor);

package/src/x_ite/Components/Shape/LineProperties.js

@@ -95,18 +95,50 @@ function (Fields,
          X3DAppearanceChildNode .prototype .initialize .call (this);
 
          this ._applied              .addInterest ("set_applied__",              this);
+         this ._linetype             .addInterest ("set_linetype__",             this);
          this ._linewidthScaleFactor .addInterest ("set_linewidthScaleFactor__", this);
 
          this .set_applied__ ();
+         this .set_linetype__ ();
          this .set_linewidthScaleFactor__ ();
       },
+      getApplied: function ()
+      {
+         return this .applied;
+      },
+      getLinetype: function ()
+      {
+         return this .linetype;
+      },
+      getLinewidthScaleFactor: function ()
+      {
+         return this .linewidthScaleFactor;
+      },
+      getMustTransformLines: function ()
+      {
+         return this .mustTransformLines;
+      },
       set_applied__: function ()
       {
          this .applied = this ._applied .getValue ();
       },
+      set_linetype__: function ()
+      {
+         let linetype = this ._linetype .getValue ();
+
+         if (linetype < 1 || linetype > 16)
+            linetype = 1;
+
+         this .linetype = linetype;
+      },
       set_linewidthScaleFactor__: function ()
       {
+         const
+            browser = this .getBrowser (),
+            gl      = browser .getContext ();
+
          this .linewidthScaleFactor = Math .max (1, this ._linewidthScaleFactor .getValue ());
+         this .mustTransformLines   = gl .MUST_TRANSFORM_LINES && this .linewidthScaleFactor > 1;
       },
       setShaderUniforms: function (gl, shaderObject)
       {
@@ -114,7 +146,7 @@ function (Fields,
          {
             const
                browser     = shaderObject .getBrowser (),
-               texture     = browser .getLinetype (this ._linetype .getValue ()),
+               texture     = browser .getLinetypeTexture (this .linetype),
                textureUnit = browser .getTexture2DUnit ();
 
             gl .lineWidth (this .linewidthScaleFactor);

package/src/x_ite/Components/Shape/PointProperties.js

@@ -53,12 +53,16 @@ define ([
    "x_ite/Base/FieldDefinitionArray",
    "x_ite/Components/Shape/X3DAppearanceChildNode",
    "x_ite/Base/X3DConstants",
+   "standard/Math/Algorithm",
+   "standard/Math/Numbers/Vector3",
 ],
 function (Fields,
           X3DFieldDefinition,
           FieldDefinitionArray,
           X3DAppearanceChildNode,
-          X3DConstants)
+          X3DConstants,
+          Algorithm,
+          Vector3)
 {
 "use strict";
 
@@ -110,6 +114,24 @@ function (Fields,
          this .set_pointSizeAttenuation__ ();
          this .set_markerType__ ();
       },
+      getPointSize: (function ()
+      {
+         const p = new Vector3 (0, 0, 0);
+
+         return function (point, modelViewMatrix)
+         {
+            const
+               pointSizeAttenuation = this .pointSizeAttenuation,
+               dL                   = modelViewMatrix .multVecMatrix (p .assign (point)) .abs ();
+
+            let pointSize = this .pointSizeScaleFactor;
+
+            pointSize /= pointSizeAttenuation [0] + pointSizeAttenuation [1] * dL + pointSizeAttenuation [2] * (dL * dL);
+            pointSize  = Algorithm .clamp (pointSize, this .pointSizeMinValue, this .pointSizeMaxValue);
+
+            return pointSize;
+         };
+      })(),
       set_pointSizeScaleFactor__: function ()
       {
          this .pointSizeScaleFactor = Math .max (1, this ._pointSizeScaleFactor .getValue ());

package/src/x_ite/Components/Shape/Shape.js

@@ -182,53 +182,46 @@ function (Fields,
             intersectionSorter = new QuickSort (intersections, function (lhs, rhs)
             {
                return lhs .point .z > rhs .point .z;
-            });
+            }),
+            distanceCompare    = function (lhs, rhs) { return lhs .point .z > rhs; };
 
          return function (renderObject)
          {
-            try
-            {
-               const
-                  browser      = renderObject .getBrowser (),
-                  geometryNode = this .getGeometry ();
+            const browser = renderObject .getBrowser ();
 
-               modelViewMatrix    .assign (renderObject .getModelViewMatrix () .get ());
-               invModelViewMatrix .assign (modelViewMatrix) .inverse ();
+            if (browser .getPickOnlySensors () && browser .getSensors () .length === 1)
+               return;
 
-               hitRay .assign (browser .getHitRay ()) .multLineMatrix (invModelViewMatrix);
+            const geometryNode = this .getGeometry ();
 
-               if (geometryNode .intersectsLine (hitRay, renderObject .getLocalObjects (), modelViewMatrix, intersections))
-               {
-                  // Finally we have intersections and must now find the closest hit in front of the camera.
+            modelViewMatrix    .assign (renderObject .getModelViewMatrix () .get ());
+            invModelViewMatrix .assign (modelViewMatrix) .inverse ();
 
-                  // Transform hitPoints to absolute space.
-                  for (const intersection of intersections)
-                     modelViewMatrix .multVecMatrix (intersection .point);
+            hitRay .assign (browser .getHitRay ()) .multLineMatrix (invModelViewMatrix);
+
+            if (geometryNode .intersectsLine (hitRay, renderObject, this .getAppearance (), intersections))
+            {
+               // Finally we have intersections and must now find the closest hit in front of the camera.
 
-                  intersectionSorter .sort (0, intersections .length);
+               // Transform hitPoints to absolute space.
+               for (const intersection of intersections)
+                  modelViewMatrix .multVecMatrix (intersection .point);
 
-                  // Find first point that is not greater than near plane;
-                  const index = Algorithm .lowerBound (intersections, 0, intersections .length, -renderObject .getNavigationInfo () .getNearValue (),
-                  function (lhs, rhs)
-                  {
-                     return lhs .point .z > rhs;
-                  });
+               intersectionSorter .sort (0, intersections .length);
 
-                  // Are there intersections before the camera?
-                  if (index !== intersections .length)
-                  {
-                     // Transform hitNormal to absolute space.
-                     invModelViewMatrix .multMatrixDir (intersections [index] .normal) .normalize ();
+               // Find first point that is not greater than near plane;
+               const index = Algorithm .lowerBound (intersections, 0, intersections .length, -renderObject .getNavigationInfo () .getNearValue (), distanceCompare);
 
-                     browser .addHit (intersections [index], renderObject .getLayer (), this, modelViewMatrix .multRight (renderObject .getCameraSpaceMatrix () .get ()));
-                  }
+               // Are there intersections before the camera?
+               if (index !== intersections .length)
+               {
+                  // Transform hitNormal to absolute space.
+                  invModelViewMatrix .multMatrixDir (intersections [index] .normal) .normalize ();
 
-                  intersections .length = 0;
+                  browser .addHit (intersections [index], renderObject .getLayer (), this, modelViewMatrix .multRight (renderObject .getCameraSpaceMatrix () .get ()));
                }
-            }
-            catch (error)
-            {
-               console .error (error);
+
+               intersections .length = 0;
             }
          };
       })(),

package/src/x_ite/Components/Sound/Sound.js

@@ -190,60 +190,50 @@ function (Fields,
 
          return function (type, renderObject)
          {
-            try
-            {
-               if (type !== TraverseType .DISPLAY)
-                  return;
+            if (type !== TraverseType .DISPLAY)
+               return;
+
+            if (! this .sourceNode)
+               return;
 
-               if (! this .sourceNode)
-                  return;
+            if (! this .sourceNode ._isActive .getValue () || this .sourceNode ._isPaused .getValue ())
+               return;
 
-               if (! this .sourceNode ._isActive .getValue () || this .sourceNode ._isPaused .getValue ())
-                  return;
+            this .setTraversed (true);
 
-               this .setTraversed (true);
+            const modelViewMatrix = renderObject .getModelViewMatrix () .get ();
 
-               const modelViewMatrix = renderObject .getModelViewMatrix () .get ();
+            this .getEllipsoidParameter (modelViewMatrix,
+                                          Math .max (this ._maxBack  .getValue (), 0),
+                                          Math .max (this ._maxFront .getValue (), 0),
+                                          max);
 
+            if (max .distance < 1) // Sphere radius is 1
+            {
                this .getEllipsoidParameter (modelViewMatrix,
-                                            Math .max (this ._maxBack  .getValue (), 0),
-                                            Math .max (this ._maxFront .getValue (), 0),
-                                            max);
+                                             Math .max (this ._minBack  .getValue (), 0),
+                                             Math .max (this ._minFront .getValue (), 0),
+                                             min);
 
-               if (max .distance < 1) // Sphere radius is 1
+               if (min .distance < 1) // Sphere radius is 1
                {
-                  this .getEllipsoidParameter (modelViewMatrix,
-                                               Math .max (this ._minBack  .getValue (), 0),
-                                               Math .max (this ._minFront .getValue (), 0),
-                                               min);
-
-                  if (min .distance < 1) // Sphere radius is 1
-                  {
-                     this .sourceNode .setVolume (this ._intensity .getValue ());
-                  }
-                  else
-                  {
-                     const
-                        d1        = max .intersection .abs (), // Viewer is here at (0, 0, 0)
-                        d2        = max .intersection .distance (min .intersection),
-                        d         = Math .min (d1 / d2, 1),
-                        intensity = Algorithm .clamp (this ._intensity .getValue (), 0, 1),
-                        volume    = intensity * d;
-
-                     this .sourceNode .setVolume (volume);
-                  }
+                  this .sourceNode .setVolume (this ._intensity .getValue ());
                }
                else
                {
-                  this .sourceNode .setVolume (0);
+                  const
+                     d1        = max .intersection .abs (), // Viewer is here at (0, 0, 0)
+                     d2        = max .intersection .distance (min .intersection),
+                     d         = Math .min (d1 / d2, 1),
+                     intensity = Algorithm .clamp (this ._intensity .getValue (), 0, 1),
+                     volume    = intensity * d;
+
+                  this .sourceNode .setVolume (volume);
                }
             }
-            catch (error)
+            else
             {
-               //console .error (error);
-
-               if (this .sourceNode)
-                  this .sourceNode .setVolume (0);
+               this .sourceNode .setVolume (0);
             }
          };
       })(),

package/src/x_ite/Components/Text/Text.js

@@ -156,29 +156,15 @@ function (Fields,
       },
       traverse: function (type, renderObject)
       {
-         try
-         {
-            this .textGeometry .traverse (type, renderObject);
-
-            X3DGeometryNode .prototype .traverse .call (this, type, renderObject);
-         }
-         catch (error)
-         {
-            console .error (error);
-         }
+         this .textGeometry .traverse (type, renderObject);
+
+         X3DGeometryNode .prototype .traverse .call (this, type, renderObject);
       },
       display: function (gl, context)
       {
-         try
-         {
-            this .textGeometry .display (gl, context);
-
-            X3DGeometryNode .prototype .display .call (this, gl, context);
-         }
-         catch (error)
-         {
-            console .error (error);
-         }
+         this .textGeometry .display (gl, context);
+
+         X3DGeometryNode .prototype .display .call (this, gl, context);
       },
       transformLine: function (line)
       {

package/src/x_ite/Components/Texturing/TextureCoordinate.js

@@ -91,27 +91,6 @@ function (Fields,
       {
          return "texCoord";
       },
-      initialize: function ()
-      {
-         X3DSingleTextureCoordinateNode .prototype .initialize .call (this);
-
-         this ._point .addInterest ("set_point__", this);
-
-         this .set_point__ ();
-      },
-      set_point__: function ()
-      {
-         this .point  = this ._point .getValue ();
-         this .length = this ._point .length;
-      },
-      isEmpty: function ()
-      {
-         return this .length === 0;
-      },
-      getSize: function ()
-      {
-         return this .length;
-      },
       get1Point: function (index, vector)
       {
          if (index >= 0 && index < this .length)
@@ -162,12 +141,12 @@ function (Fields,
       },
       getTexCoord: function (array)
       {
-         const point = this .point;
-
-         for (let i = 0, p = 0, length = this .length; i < length; ++ i, p += 2)
-            array [i] = new Vector4 (point [p], point [p + 1], 0, 1);
+         const
+            point  = this .point,
+            length = this .length;
 
-         array .length = this .length;
+         for (let i = 0, p = 0; i < length; ++ i, p += 2)
+            array .push (point [p], point [p + 1], 0, 1);
 
          return array;
       },

package/src/x_ite/Components/Texturing/TextureProperties.js

@@ -80,12 +80,12 @@ function (Fields,
          new X3DFieldDefinition (X3DConstants .inputOutput,    "borderWidth",         new Fields .SFInt32 ()),
          new X3DFieldDefinition (X3DConstants .inputOutput,    "anisotropicDegree",   new Fields .SFFloat (1)),
          new X3DFieldDefinition (X3DConstants .initializeOnly, "generateMipMaps",     new Fields .SFBool ()),
-         new X3DFieldDefinition (X3DConstants .inputOutput,    "minificationFilter",  new Fields .SFString ("FASTEST")),
-         new X3DFieldDefinition (X3DConstants .inputOutput,    "magnificationFilter", new Fields .SFString ("FASTEST")),
+         new X3DFieldDefinition (X3DConstants .inputOutput,    "minificationFilter",  new Fields .SFString ("DEFAULT")),
+         new X3DFieldDefinition (X3DConstants .inputOutput,    "magnificationFilter", new Fields .SFString ("DEFAULT")),
          new X3DFieldDefinition (X3DConstants .inputOutput,    "boundaryModeS",       new Fields .SFString ("REPEAT")),
          new X3DFieldDefinition (X3DConstants .inputOutput,    "boundaryModeT",       new Fields .SFString ("REPEAT")),
          new X3DFieldDefinition (X3DConstants .inputOutput,    "boundaryModeR",       new Fields .SFString ("REPEAT")),
-         new X3DFieldDefinition (X3DConstants .inputOutput,    "textureCompression",  new Fields .SFString ("FASTEST")),
+         new X3DFieldDefinition (X3DConstants .inputOutput,    "textureCompression",  new Fields .SFString ("DEFAULT")),
          new X3DFieldDefinition (X3DConstants .inputOutput,    "texturePriority",     new Fields .SFFloat ()),
       ]),
       getTypeName: function ()
@@ -201,7 +201,7 @@ function (Fields,
             const
                browser            = this .getBrowser (),
                gl                 = browser .getContext (),
-               compressedTexture  = browser .getExtension ("WEBGL_compressed_texture_etc"), // TODO: find suitable compression.
+               compressedTexture  = gl .getExtension ("WEBGL_compressed_texture_etc"), // TODO: find suitable compression.
                textureCompression = compressedTexture ? compressedTexture [textureCompressions .get (this ._textureCompression .getValue ())] : undefined;
 
             if (textureCompression !== undefined)

package/src/x_ite/Components/Texturing/X3DSingleTextureCoordinateNode.js

@@ -70,6 +70,27 @@ function (X3DTextureCoordinateNode,
    X3DSingleTextureCoordinateNode .prototype = Object .assign (Object .create (X3DTextureCoordinateNode .prototype),
    {
       constructor: X3DSingleTextureCoordinateNode,
+      initialize: function ()
+      {
+         X3DTextureCoordinateNode .prototype .initialize .call (this);
+
+         this ._point .addInterest ("set_point__", this);
+
+         this .set_point__ ();
+      },
+      set_point__: function ()
+      {
+         this .point  = this ._point .getValue ();
+         this .length = this ._point .length;
+      },
+      isEmpty: function ()
+      {
+         return this .length === 0;
+      },
+      getSize: function ()
+      {
+         return this .length;
+      },
       init: function (multiArray)
       {
          this .texCoordArray .length = 0;

package/src/x_ite/Components/Texturing/X3DSingleTextureNode.js

@@ -78,15 +78,15 @@ function (X3DTextureNode,
       {
          X3DTextureNode .prototype .initialize .call (this);
 
-         this ._textureProperties .addInterest ("set_textureProperties__", this);
+         this ._textureProperties .addInterest ("set_textureProperties__", this, true);
 
          const gl = this .getBrowser () .getContext ();
 
          this .texture = gl .createTexture ();
 
-         this .set_textureProperties__ ();
+         this .set_textureProperties__ (false);
       },
-      set_textureProperties__: function ()
+      set_textureProperties__: function (update)
       {
          if (this .texturePropertiesNode)
             this .texturePropertiesNode .removeInterest ("updateTextureProperties", this);
@@ -98,7 +98,8 @@ function (X3DTextureNode,
 
          this .texturePropertiesNode .addInterest ("updateTextureProperties", this);
 
-         this .updateTextureProperties ();
+         if (update)
+            this .updateTextureProperties ();
       },
       getTexture: function ()
       {

package/src/x_ite/Components/Texturing/X3DTexture2DNode.js

@@ -124,46 +124,37 @@ function (X3DSingleTextureNode,
       },
       setTexture: function (width, height, transparent, data, flipY)
       {
-         try
-         {
-            this .width  = width;
-            this .height = height;
-            this .flipY  = flipY;
-            this .data   = data;
-
-            const gl = this .getBrowser () .getContext ();
-
-            gl .pixelStorei (gl .UNPACK_FLIP_Y_WEBGL, flipY);
-            gl .pixelStorei (gl .UNPACK_ALIGNMENT, 1);
-            gl .bindTexture (gl .TEXTURE_2D, this .getTexture ());
-            gl .texImage2D  (gl .TEXTURE_2D, 0, gl .RGBA, width, height, 0, gl .RGBA, gl .UNSIGNED_BYTE, data);
-
-            this .setTransparent (transparent);
-            this .updateTextureProperties ();
-            this .addNodeEvent ();
-         }
-         catch (error)
-         { }
+         this .width  = width;
+         this .height = height;
+         this .flipY  = flipY;
+         this .data   = data;
+
+         const gl = this .getBrowser () .getContext ();
+
+         gl .pixelStorei (gl .UNPACK_FLIP_Y_WEBGL, flipY);
+         gl .bindTexture (gl .TEXTURE_2D, this .getTexture ());
+         gl .texImage2D  (gl .TEXTURE_2D, 0, gl .RGBA, width, height, 0, gl .RGBA, gl .UNSIGNED_BYTE, data);
+         gl .pixelStorei (gl .UNPACK_FLIP_Y_WEBGL, false);
+
+         this .setTransparent (transparent);
+         this .updateTextureProperties ();
+         this .addNodeEvent ();
       },
       updateTexture: function (data, flipY)
       {
-         try
-         {
-            this .data = data;
+         this .data = data;
 
-            const gl = this .getBrowser () .getContext ();
+         const gl = this .getBrowser () .getContext ();
 
-            gl .pixelStorei (gl .UNPACK_FLIP_Y_WEBGL, flipY);
-            gl .bindTexture (gl .TEXTURE_2D, this .getTexture ());
-            gl .texSubImage2D (gl .TEXTURE_2D, 0, 0, 0, gl .RGBA, gl .UNSIGNED_BYTE, data);
+         gl .pixelStorei (gl .UNPACK_FLIP_Y_WEBGL, flipY);
+         gl .bindTexture (gl .TEXTURE_2D, this .getTexture ());
+         gl .texSubImage2D (gl .TEXTURE_2D, 0, 0, 0, gl .RGBA, gl .UNSIGNED_BYTE, data);
+         gl .pixelStorei (gl .UNPACK_FLIP_Y_WEBGL, false);
 
-            if (this .texturePropertiesNode ._generateMipMaps .getValue ())
-               gl .generateMipmap (gl .TEXTURE_2D);
+         if (this .texturePropertiesNode ._generateMipMaps .getValue ())
+            gl .generateMipmap (gl .TEXTURE_2D);
 
-            this .addNodeEvent ();
-         }
-         catch (error)
-         { }
+         this .addNodeEvent ();
       },
       updateTextureProperties: function ()
       {

package/src/x_ite/Components/Texturing3D/TextureCoordinate3D.js

@@ -91,27 +91,6 @@ function (Fields,
       {
          return "texCoord";
       },
-      initialize: function ()
-      {
-         X3DSingleTextureCoordinateNode .prototype .initialize .call (this);
-
-         this ._point .addInterest ("set_point__", this);
-
-         this .set_point__ ();
-      },
-      set_point__: function ()
-      {
-         this .point  = this ._point .getValue ();
-         this .length = this ._point .length;
-      },
-      isEmpty: function ()
-      {
-         return this .length === 0;
-      },
-      getSize: function ()
-      {
-         return this .length;
-      },
       get1Point: function (index, vector)
       {
          if (index >= 0 && index < this .length)
@@ -162,12 +141,12 @@ function (Fields,
       },
       getTexCoord: function (array)
       {
-         const point = this .point;
-
-         for (let i = 0, p = 0, length = this .length; i < length; ++ i, p += 3)
-            array [i] = new Vector4 (point [p], point [p + 1], point [p + 2], 1);
+         const
+            point  = this .point,
+            length = this .length;
 
-         array .length = this .length;
+         for (let i = 0, p = 0; i < length; ++ i, p += 3)
+            array .push (point [p], point [p + 1], point [p + 2], 1);
 
          return array;
       },