x_ite 5.0.3 → 6.1.0

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

@@ -70,8 +70,9 @@ function (Fields,
 
       this .addChildObjects ("activationTime", new Fields .SFTime ());
 
-      this .valid    = false;
-      this .selected = 0;
+      this .valid          = false;
+      this .selected       = 0;
+      this .primitiveModes = new Map ();
    }
 
    X3DShaderNode .prototype = Object .assign (Object .create (X3DAppearanceChildNode .prototype),
@@ -91,26 +92,32 @@ function (Fields,
       {
          this ._isValid = this .valid = value;
       },
-      getValid: function ()
+      isValid: function ()
       {
          return this .valid;
       },
       setShading: function (shading)
       {
-         var gl = this .getBrowser () .getContext ();
+         const gl = this .getBrowser () .getContext ();
 
          switch (shading)
          {
             case Shading .POINT:
             {
-               this .primitiveMode = gl .POINTS;
-               this .wireframe     = true;
+               this .wireframe = false;
+
+               this .primitiveModes .set (gl .POINTS,    gl .POINTS);
+               this .primitiveModes .set (gl .LINES,     gl .POINTS);
+               this .primitiveModes .set (gl .TRIANGLES, gl .POINTS);
                break;
             }
             case Shading .WIREFRAME:
             {
-               this .primitiveMode = gl .LINE_LOOP;
-               this .wireframe     = true;
+               this .wireframe = true;
+
+               this .primitiveModes .set (gl .POINTS,    gl .POINTS);
+               this .primitiveModes .set (gl .LINES,     gl .LINES);
+               this .primitiveModes .set (gl .TRIANGLES, gl .LINE_LOOP);
                break;
             }
             default:
@@ -119,12 +126,23 @@ function (Fields,
                // case Shading .GOURAUD:
                // case Shading .PHONG:
 
-               this .primitiveMode = gl .TRIANGLES;
-               this .wireframe     = false;
+               this .wireframe = false;
+
+               this .primitiveModes .set (gl .POINTS,    gl .POINTS);
+               this .primitiveModes .set (gl .LINES,     gl .LINES);
+               this .primitiveModes .set (gl .TRIANGLES, gl .TRIANGLES);
                break;
             }
          }
       },
+      getWireframe: function ()
+      {
+         return this .wireframe;
+      },
+      getPrimitiveMode: function (primitiveMode)
+      {
+         return this .primitiveModes .get (primitiveMode);
+      },
       select: function ()
       {
          ++ this .selected;

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,23 @@ 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);
+      },
+      set_attribute__: function ()
+      {
+         this ._attribute_changed = this .getBrowser () .getCurrentTime ();
+      },
    });
 
    return X3DVertexAttributeNode;

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

@@ -154,6 +154,42 @@ function (Fields,
       {
          return this .alphaMode;
       },
+      getPointProperties: function ()
+      {
+         return this .stylePropertiesNode [0];
+      },
+      getLineProperties: function ()
+      {
+         return this .stylePropertiesNode [1];
+      },
+      getFillProperties: function ()
+      {
+         return this .stylePropertiesNode [2];
+      },
+      getMaterial: function ()
+      {
+         return this .materialNode;
+      },
+      getBackMaterial: function ()
+      {
+         return this .backMaterialNode;
+      },
+      getTexture: function ()
+      {
+         return this .textureNode;
+      },
+      getTextureTransform: function ()
+      {
+         return this .textureTransformNode;
+      },
+      getShader: function ()
+      {
+         return this .shaderNode;
+      },
+      getBlendMode: function ()
+      {
+         return this .blendModeNode;
+      },
       set_live__: function ()
       {
          if (this .isLive () .getValue ())
@@ -226,10 +262,7 @@ function (Fields,
          // Depreciated TwoSidedMaterial handling.
 
          if (this .materialNode .getTypeName () === "TwoSidedMaterial")
-         {
-            console .warn ("TwoSidedMaterial is depreciated, please use Appearance backMaterial.");
             this .set_backMaterial__ ();
-         }
       },
       set_backMaterial__: function ()
       {
@@ -243,7 +276,7 @@ function (Fields,
 
          // Depreciated TwoSidedMaterial handling.
 
-         if (!this .backMaterialNode && this .materialNode .getTypeName () === "TwoSidedMaterial")
+         if (! this .backMaterialNode && this .materialNode .getTypeName () === "TwoSidedMaterial")
             this .backMaterialNode = this .materialNode;
       },
       set_texture__: function ()

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";
 
@@ -98,6 +102,10 @@ function (Fields,
       {
          X3DAppearanceChildNode .prototype .initialize .call (this);
 
+         const gl = this .getBrowser () .getContext ();
+
+         this .pointSizeRange = gl .getParameter (gl .ALIASED_POINT_SIZE_RANGE);
+
          this ._pointSizeScaleFactor .addInterest ("set_pointSizeScaleFactor__", this);
          this ._pointSizeMinValue    .addInterest ("set_pointSizeMinValue__",    this);
          this ._pointSizeMaxValue    .addInterest ("set_pointSizeMaxValue__",    this);
@@ -110,17 +118,30 @@ function (Fields,
          this .set_pointSizeAttenuation__ ();
          this .set_markerType__ ();
       },
+      getPointSize: function (point)
+      {
+         const
+            pointSizeAttenuation = this .pointSizeAttenuation,
+            dL                   = point .magnitude ();
+
+         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 ());
       },
       set_pointSizeMinValue__: function ()
       {
-         this .pointSizeMinValue = Math .max (0, this ._pointSizeMinValue .getValue ());
+         this .pointSizeMinValue = Algorithm .clamp (this ._pointSizeMinValue .getValue (), this .pointSizeRange [0], this .pointSizeRange [1]);
       },
       set_pointSizeMaxValue__: function ()
       {
-         this .pointSizeMaxValue = Math .max (0, this ._pointSizeMaxValue .getValue ());
+         this .pointSizeMaxValue = Algorithm .clamp (this ._pointSizeMaxValue .getValue (), this .pointSizeRange [0], this .pointSizeRange [1]);
       },
       set_pointSizeAttenuation__: function ()
       {

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

@@ -57,7 +57,6 @@ define ([
    "standard/Math/Algorithm",
    "standard/Math/Numbers/Vector3",
    "standard/Math/Numbers/Matrix4",
-   "standard/Math/Geometry/Box3",
    "standard/Math/Geometry/Line3",
    "standard/Math/Algorithms/QuickSort",
 ],
@@ -70,7 +69,6 @@ function (Fields,
           Algorithm,
           Vector3,
           Matrix4,
-          Box3,
           Line3,
           QuickSort)
 {
@@ -182,62 +180,55 @@ 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);
 
-                  intersectionSorter .sort (0, intersections .length);
+            if (geometryNode .intersectsLine (hitRay, renderObject, invModelViewMatrix, this .getAppearance (), intersections))
+            {
+               // Finally we have intersections and must now find the closest hit in front of the camera.
 
-                  // 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;
-                  });
+               // Transform hitPoints to absolute space.
+               for (const intersection of intersections)
+                  modelViewMatrix .multVecMatrix (intersection .point);
 
-                  // Are there intersections before the camera?
-                  if (index !== intersections .length)
-                  {
-                     // Transform hitNormal to absolute space.
-                     invModelViewMatrix .multMatrixDir (intersections [index] .normal) .normalize ();
+               intersectionSorter .sort (0, intersections .length);
 
-                     browser .addHit (intersections [index], renderObject .getLayer (), this, modelViewMatrix .multRight (renderObject .getCameraSpaceMatrix () .get ()));
-                  }
+               // Find first point that is not greater than near plane;
+               const index = Algorithm .lowerBound (intersections, 0, intersections .length, -renderObject .getNavigationInfo () .getNearValue (), distanceCompare);
+
+               // 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;
             }
          };
       })(),
       picking: function (renderObject)
       {
+         const modelMatrix = renderObject .getModelViewMatrix () .get ();
+
          if (this .getTransformSensors () .size)
          {
-            const modelMatrix = renderObject .getModelViewMatrix () .get ();
-
             for (const transformSensorNode of this .getTransformSensors ())
                transformSensorNode .collect (modelMatrix);
          }
@@ -251,7 +242,7 @@ function (Fields,
 
          for (const pickSensor of pickSensorStack .at (-1))
          {
-            pickSensor .collect (this .getGeometry (), renderObject .getModelViewMatrix () .get (), browser .getPickingHierarchy ());
+            pickSensor .collect (this .getGeometry (), modelMatrix, pickingHierarchy);
          }
 
          pickingHierarchy .pop ();

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

@@ -66,6 +66,8 @@ function (Fields,
 
    function TwoSidedMaterial (executionContext)
    {
+      console .warn ("TwoSidedMaterial is depreciated, please use Appearance backMaterial field.");
+
       X3DMaterialNode .call (this, executionContext);
 
       this .addType (X3DConstants .TwoSidedMaterial);
@@ -263,7 +265,7 @@ function (Fields,
       },
       setShaderUniforms: function (gl, shaderObject, renderObject, textureTransformMapping, textureCoordinateMapping, front)
       {
-         if (!front && this ._separateBackColor .getValue ())
+         if (! front && this ._separateBackColor .getValue ())
          {
             gl .uniform1f  (shaderObject .x3d_AmbientIntensity, this .backAmbientIntensity);
             gl .uniform3fv (shaderObject .x3d_DiffuseColor,     this .backDiffuseColor);

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 .magnitude (), // 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);
             }
          };
       })(),
@@ -305,7 +295,7 @@ function (Fields,
             sphere .intersectsLine (line, enterPoint, exitPoint);
 
             value .intersection .assign (sphereMatrix .multVecMatrix (enterPoint));
-            value .distance = viewer .abs ();
+            value .distance = viewer .magnitude ();
          };
       })(),
    });

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/ImageTexture.js

@@ -174,7 +174,7 @@ function ($,
                gl     = this .getBrowser () .getContext (),
                image  = this .image [0],
                canvas = this .canvas [0],
-               cx     = canvas .getContext ("2d");
+               cx     = canvas .getContext ("2d", { willReadFrequently: true });
 
             let
                width  = image .width,

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

@@ -208,7 +208,7 @@ function ($,
                width  = video .videoWidth,
                height = video .videoHeight,
                canvas = this .canvas [0],
-               cx     = canvas .getContext ("2d");
+               cx     = canvas .getContext ("2d", { willReadFrequently: true });
 
             if (! Algorithm .isPowerOfTwo (width) || ! Algorithm .isPowerOfTwo (height))
                throw new Error ("The movie texture is a non power-of-two texture.");

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

@@ -247,8 +247,8 @@ function ($,
                const
                   canvas1   = this .canvas1 [0],
                   canvas2   = this .canvas2 [0],
-                  cx1       = canvas1 .getContext("2d"),
-                  cx2       = canvas2 .getContext("2d"),
+                  cx1       = canvas1 .getContext ("2d", { willReadFrequently: true }),
+                  cx2       = canvas2 .getContext ("2d", { willReadFrequently: true }),
                   imageData = cx1 .createImageData (width, height);
 
                canvas1 .width  = width;

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

@@ -162,12 +162,12 @@ function (Fields,
       },
       getTexCoord: function (array)
       {
-         const point = this .point;
+         const
+            point  = this .point,
+            length = this .length;
 
-         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);
-
-         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;
       },