x_ite 5.0.3 → 6.1.0

package/src/x_ite/Components/PointingDeviceSensor/SphereSensor.js

@@ -129,7 +129,7 @@ function (Fields,
 
          if (this .sphere .intersectsLine (hitRay, trackPoint, exit))
          {
-            if ((Vector3 .subtract (hitRay .point, exit) .abs () < Vector3 .subtract (hitRay .point, trackPoint) .abs ()) - behind)
+            if ((Vector3 .subtract (hitRay .point, exit) .magnitude () < Vector3 .subtract (hitRay .point, trackPoint) .magnitude ()) - behind)
                trackPoint .assign (exit);
 
             return true;
@@ -141,97 +141,80 @@ function (Fields,
       {
          X3DDragSensorNode .prototype .set_active__ .call (this, active, hit, modelViewMatrix, projectionMatrix, viewport);
 
-         try
+         if (this ._isActive .getValue ())
          {
-            if (this ._isActive .getValue ())
-            {
-               this .modelViewMatrix    .assign (modelViewMatrix);
-               this .invModelViewMatrix .assign (modelViewMatrix) .inverse ();
-
-               var
-                  hitPoint = this .invModelViewMatrix .multVecMatrix (hit .intersection .point .copy ()),
-                  center   = new Vector3 (0, 0, 0);
-
-               this .zPlane = new Plane3 (center, this .invModelViewMatrix .multDirMatrix (new Vector3 (0, 0, 1)) .normalize ()); // Screen aligned Z-plane
-               this .sphere = new Sphere3 (hitPoint .abs (), center);
-               this .behind = this .zPlane .getDistanceToPoint (hitPoint) < 0;
-
-               this .fromVector  .assign (hitPoint);
-               this .startPoint  .assign (hitPoint);
-               this .startOffset .assign (this ._offset .getValue ());
-
-               this ._trackPoint_changed = hitPoint;
-               this ._rotation_changed   = this ._offset .getValue ();
-            }
-            else
-            {
-               if (this ._autoOffset .getValue ())
-                  this ._offset = this ._rotation_changed;
-            }
+            this .modelViewMatrix    .assign (modelViewMatrix);
+            this .invModelViewMatrix .assign (modelViewMatrix) .inverse ();
+
+            var
+               hitPoint = this .invModelViewMatrix .multVecMatrix (hit .intersection .point .copy ()),
+               center   = new Vector3 (0, 0, 0);
+
+            this .zPlane = new Plane3 (center, this .invModelViewMatrix .multDirMatrix (new Vector3 (0, 0, 1)) .normalize ()); // Screen aligned Z-plane
+            this .sphere = new Sphere3 (hitPoint .magnitude (), center);
+            this .behind = this .zPlane .getDistanceToPoint (hitPoint) < 0;
+
+            this .fromVector  .assign (hitPoint);
+            this .startPoint  .assign (hitPoint);
+            this .startOffset .assign (this ._offset .getValue ());
+
+            this ._trackPoint_changed = hitPoint;
+            this ._rotation_changed   = this ._offset .getValue ();
          }
-         catch (error)
+         else
          {
-            //console .error (error);
+            if (this ._autoOffset .getValue ())
+               this ._offset = this ._rotation_changed;
          }
       },
       set_motion__: function (hit)
       {
-         try
-         {
-            var
-               hitRay     = hit .hitRay .copy () .multLineMatrix (this .invModelViewMatrix),
-               trackPoint = new Vector3 (0, 0, 0);
+         var
+            hitRay     = hit .hitRay .copy () .multLineMatrix (this .invModelViewMatrix),
+            trackPoint = new Vector3 (0, 0, 0);
 
-            if (this .getTrackPoint (hitRay, trackPoint, this .behind))
-            {
-               var zAxis = this .invModelViewMatrix .multDirMatrix (new Vector3 (0, 0, 1)) .normalize (); // Camera direction
-               this .zPlane = new Plane3 (trackPoint, zAxis);                                             // Screen aligned Z-plane
-            }
-            else
-            {
-               // Find trackPoint on the plane with sphere
-
-               var tangentPoint = new Vector3 (0, 0, 0);
-               this .zPlane .intersectsLine (hitRay, tangentPoint);
+         if (this .getTrackPoint (hitRay, trackPoint, this .behind))
+         {
+            var zAxis = this .invModelViewMatrix .multDirMatrix (new Vector3 (0, 0, 1)) .normalize (); // Camera direction
+            this .zPlane = new Plane3 (trackPoint, zAxis);                                             // Screen aligned Z-plane
+         }
+         else
+         {
+            // Find trackPoint on the plane with sphere
 
-               hitRay = new Line3 (tangentPoint, Vector3 .subtract (this .sphere .center, tangentPoint) .normalize ());
+            var tangentPoint = new Vector3 (0, 0, 0);
+            this .zPlane .intersectsLine (hitRay, tangentPoint);
 
-               //console .log (hitRay .toString ());
+            hitRay = new Line3 (tangentPoint, Vector3 .subtract (this .sphere .center, tangentPoint) .normalize ());
 
-               this .getTrackPoint (hitRay, trackPoint, false);
+            //console .log (hitRay .toString ());
 
-               // Find trackPoint behind sphere
+            this .getTrackPoint (hitRay, trackPoint, false);
 
-               var
-                  triNormal     = Triangle3 .normal (this .sphere .center, trackPoint, this .startPoint, new Vector3 (0, 0, 0)),
-                  dirFromCenter = Vector3 .subtract (trackPoint, this .sphere .center) .normalize (),
-                  normal        = Vector3 .cross (triNormal, dirFromCenter) .normalize ();
+            // Find trackPoint behind sphere
 
-               var point1 = Vector3 .subtract (trackPoint, normal .multiply (Vector3 .subtract (tangentPoint, trackPoint) .abs ()));
+            var
+               triNormal     = Triangle3 .normal (this .sphere .center, trackPoint, this .startPoint, new Vector3 (0, 0, 0)),
+               dirFromCenter = Vector3 .subtract (trackPoint, this .sphere .center) .normalize (),
+               normal        = Vector3 .cross (triNormal, dirFromCenter) .normalize ();
 
-               hitRay = new Line3 (point1, Vector3 .subtract (this .sphere .center, point1) .normalize ());
+            var point1 = Vector3 .subtract (trackPoint, normal .multiply (Vector3 .subtract (tangentPoint, trackPoint) .magnitude ()));
 
-               this .getTrackPoint (hitRay, trackPoint, false);
-            }
+            hitRay = new Line3 (point1, Vector3 .subtract (this .sphere .center, point1) .normalize ());
 
-            this ._trackPoint_changed = trackPoint;
+            this .getTrackPoint (hitRay, trackPoint, false);
+         }
 
-            var
-               toVector = Vector3 .subtract (trackPoint, this .sphere .center),
-               rotation = new Rotation4 (this .fromVector, toVector);
+         this ._trackPoint_changed = trackPoint;
 
-            if (this .behind)
-               rotation .inverse ();
+         var
+            toVector = Vector3 .subtract (trackPoint, this .sphere .center),
+            rotation = new Rotation4 (this .fromVector, toVector);
 
-            this ._rotation_changed = Rotation4 .multRight (this .startOffset, rotation);
-         }
-         catch (error)
-         {
-            //console .error (error);
+         if (this .behind)
+            rotation .inverse ();
 
-            this ._trackPoint_changed .addEvent ();
-            this ._rotation_changed   .addEvent ();
-         }
+         this ._rotation_changed = Rotation4 .multRight (this .startOffset, rotation);
       },
    });
 

package/src/x_ite/Components/PointingDeviceSensor/TouchSensor.js

@@ -103,24 +103,17 @@ function (Fields,
       },
       set_over__: function (over, hit, modelViewMatrix, projectionMatrix, viewport)
       {
-         try
-         {
-            X3DTouchSensorNode .prototype .set_over__ .call (this, over, hit, modelViewMatrix, projectionMatrix, viewport);
+         X3DTouchSensorNode .prototype .set_over__ .call (this, over, hit, modelViewMatrix, projectionMatrix, viewport);
 
-            if (this ._isOver .getValue ())
-            {
-               var intersection = hit .intersection;
+         if (this ._isOver .getValue ())
+         {
+            var intersection = hit .intersection;
 
-               invModelViewMatrix .assign (modelViewMatrix) .inverse ();
+            invModelViewMatrix .assign (modelViewMatrix) .inverse ();
 
-               this ._hitTexCoord_changed = intersection .texCoord;
-               this ._hitNormal_changed   = modelViewMatrix .multMatrixDir (intersection .normal .copy ()) .normalize ();
-               this ._hitPoint_changed    = invModelViewMatrix .multVecMatrix (intersection .point .copy ());
-            }
-         }
-         catch (error)
-         {
-            console .error (error);
+            this ._hitTexCoord_changed = intersection .texCoord;
+            this ._hitNormal_changed   = modelViewMatrix .multMatrixDir (intersection .normal .copy ()) .normalize ();
+            this ._hitPoint_changed    = invModelViewMatrix .multVecMatrix (intersection .point .copy ());
          }
       },
    });

package/src/x_ite/Components/ProjectiveTextureMapping/TextureProjectorParallel.js

@@ -105,66 +105,59 @@ function (Fields,
       },
       setGlobalVariables: function (renderObject)
       {
-         try
-         {
-            var
-               textureProjectorNode  = this .textureProjectorNode,
-               cameraSpaceMatrix     = renderObject .getCameraSpaceMatrix () .get (),
-               modelMatrix           = this .modelMatrix .assign (this .modelViewMatrix) .multRight (cameraSpaceMatrix),
-               invTextureSpaceMatrix = this .invTextureSpaceMatrix .assign (textureProjectorNode .getGlobal () ? modelMatrix : Matrix4 .Identity);
+         var
+            textureProjectorNode  = this .textureProjectorNode,
+            cameraSpaceMatrix     = renderObject .getCameraSpaceMatrix () .get (),
+            modelMatrix           = this .modelMatrix .assign (this .modelViewMatrix) .multRight (cameraSpaceMatrix),
+            invTextureSpaceMatrix = this .invTextureSpaceMatrix .assign (textureProjectorNode .getGlobal () ? modelMatrix : Matrix4 .Identity);
 
-            this .rotation .setFromToVec (Vector3 .zAxis, this .direction .assign (textureProjectorNode .getDirection ()) .negate ());
-            textureProjectorNode .straightenHorizon (this .rotation);
+         this .rotation .setFromToVec (Vector3 .zAxis, this .direction .assign (textureProjectorNode .getDirection ()) .negate ());
+         textureProjectorNode .straightenHorizon (this .rotation);
 
-            invTextureSpaceMatrix .translate (textureProjectorNode .getLocation ());
-            invTextureSpaceMatrix .rotate (this .rotation);
-            invTextureSpaceMatrix .inverse ();
+         invTextureSpaceMatrix .translate (textureProjectorNode .getLocation ());
+         invTextureSpaceMatrix .rotate (this .rotation);
+         invTextureSpaceMatrix .inverse ();
 
-            var
-               width        = textureProjectorNode .getTexture () .getWidth (),
-               height       = textureProjectorNode .getTexture () .getHeight (),
-               aspect       = width / height,
-               minimumX     = textureProjectorNode .getMinimumX (),
-               maximumX     = textureProjectorNode .getMaximumX (),
-               minimumY     = textureProjectorNode .getMinimumY (),
-               maximumY     = textureProjectorNode .getMaximumY (),
-               sizeX        = textureProjectorNode .getSizeX (),
-               sizeY        = textureProjectorNode .getSizeY (),
-               nearDistance = textureProjectorNode .getNearDistance (),
-               farDistance  = textureProjectorNode .getFarDistance ();
+         var
+            width        = textureProjectorNode .getTexture () .getWidth (),
+            height       = textureProjectorNode .getTexture () .getHeight (),
+            aspect       = width / height,
+            minimumX     = textureProjectorNode .getMinimumX (),
+            maximumX     = textureProjectorNode .getMaximumX (),
+            minimumY     = textureProjectorNode .getMinimumY (),
+            maximumY     = textureProjectorNode .getMaximumY (),
+            sizeX        = textureProjectorNode .getSizeX (),
+            sizeY        = textureProjectorNode .getSizeY (),
+            nearDistance = textureProjectorNode .getNearDistance (),
+            farDistance  = textureProjectorNode .getFarDistance ();
 
-            if (aspect > sizeX / sizeY)
-            {
-               var
-                  center  = (minimumX + maximumX) / 2,
-                  size1_2 = (sizeY * aspect) / 2;
+         if (aspect > sizeX / sizeY)
+         {
+            var
+               center  = (minimumX + maximumX) / 2,
+               size1_2 = (sizeY * aspect) / 2;
 
-               Camera .ortho (center - size1_2, center + size1_2, minimumY, maximumY, nearDistance, farDistance, this .projectionMatrix);
-            }
-            else
-            {
-               var
-                  center  = (minimumY + maximumY) / 2,
-                  size1_2 = (sizeX / aspect) / 2;
+            Camera .ortho (center - size1_2, center + size1_2, minimumY, maximumY, nearDistance, farDistance, this .projectionMatrix);
+         }
+         else
+         {
+            var
+               center  = (minimumY + maximumY) / 2,
+               size1_2 = (sizeX / aspect) / 2;
 
-               Camera .ortho (minimumX, maximumX, center - size1_2, center + size1_2, nearDistance, farDistance, this .projectionMatrix);
-            }
+            Camera .ortho (minimumX, maximumX, center - size1_2, center + size1_2, nearDistance, farDistance, this .projectionMatrix);
+         }
 
-            if (! textureProjectorNode .getGlobal ())
-               invTextureSpaceMatrix .multLeft (modelMatrix .inverse ());
+         if (! textureProjectorNode .getGlobal ())
+            invTextureSpaceMatrix .multLeft (modelMatrix .inverse ());
 
-            this .invTextureSpaceProjectionMatrix .assign (invTextureSpaceMatrix) .multRight (this .projectionMatrix) .multRight (textureProjectorNode .getBiasMatrix ());
+         this .invTextureSpaceProjectionMatrix .assign (invTextureSpaceMatrix) .multRight (this .projectionMatrix) .multRight (textureProjectorNode .getBiasMatrix ());
 
-            this .projectiveTextureMatrix .assign (cameraSpaceMatrix) .multRight (this .invTextureSpaceProjectionMatrix);
-            this .projectiveTextureMatrixArray .set (this .projectiveTextureMatrix);
+         this .projectiveTextureMatrix .assign (cameraSpaceMatrix) .multRight (this .invTextureSpaceProjectionMatrix);
+         this .projectiveTextureMatrixArray .set (this .projectiveTextureMatrix);
 
-            this .modelViewMatrix .multVecMatrix (this .location .assign (textureProjectorNode ._location .getValue ()));
-            this .locationArray .set (this .location);
-         }
-         catch (error)
-         {
-            console .error (error);
-         }
+         this .modelViewMatrix .multVecMatrix (this .location .assign (textureProjectorNode ._location .getValue ()));
+         this .locationArray .set (this .location);
       },
       setShaderUniforms: function (gl, shaderObject, renderObject)
       {

package/src/x_ite/Components/ProjectiveTextureMapping/TextureProjectorPerspective.js

@@ -105,45 +105,38 @@ function (Fields,
       },
       setGlobalVariables: function (renderObject)
       {
-         try
-         {
-            var
-               textureProjectorNode  = this .textureProjectorNode,
-               cameraSpaceMatrix     = renderObject .getCameraSpaceMatrix () .get (),
-               modelMatrix           = this .modelMatrix .assign (this .modelViewMatrix) .multRight (cameraSpaceMatrix),
-               invTextureSpaceMatrix = this .invTextureSpaceMatrix .assign (textureProjectorNode .getGlobal () ? modelMatrix : Matrix4 .Identity);
-
-            this .rotation .setFromToVec (Vector3 .zAxis, this .direction .assign (textureProjectorNode .getDirection ()) .negate ());
-            textureProjectorNode .straightenHorizon (this .rotation);
-
-            invTextureSpaceMatrix .translate (textureProjectorNode .getLocation ());
-            invTextureSpaceMatrix .rotate (this .rotation);
-            invTextureSpaceMatrix .inverse ();
-
-            var
-               width            = textureProjectorNode .getTexture () .getWidth (),
-               height           = textureProjectorNode .getTexture () .getHeight (),
-               nearDistance     = textureProjectorNode .getNearDistance (),
-               farDistance      = textureProjectorNode .getFarDistance (),
-               fieldOfView      = textureProjectorNode .getFieldOfView ();
-
-            Camera .perspective (fieldOfView, nearDistance, farDistance, width, height, this .projectionMatrix);
-
-            if (! textureProjectorNode .getGlobal ())
-               invTextureSpaceMatrix .multLeft (modelMatrix .inverse ());
-
-            this .invTextureSpaceProjectionMatrix .assign (invTextureSpaceMatrix) .multRight (this .projectionMatrix) .multRight (textureProjectorNode .getBiasMatrix ());
-
-            this .projectiveTextureMatrix .assign (cameraSpaceMatrix) .multRight (this .invTextureSpaceProjectionMatrix);
-            this .projectiveTextureMatrixArray .set (this .projectiveTextureMatrix);
-
-            this .modelViewMatrix .multVecMatrix (this .location .assign (textureProjectorNode ._location .getValue ()));
-            this .locationArray .set (this .location);
-         }
-         catch (error)
-         {
-            console .error (error);
-         }
+         var
+            textureProjectorNode  = this .textureProjectorNode,
+            cameraSpaceMatrix     = renderObject .getCameraSpaceMatrix () .get (),
+            modelMatrix           = this .modelMatrix .assign (this .modelViewMatrix) .multRight (cameraSpaceMatrix),
+            invTextureSpaceMatrix = this .invTextureSpaceMatrix .assign (textureProjectorNode .getGlobal () ? modelMatrix : Matrix4 .Identity);
+
+         this .rotation .setFromToVec (Vector3 .zAxis, this .direction .assign (textureProjectorNode .getDirection ()) .negate ());
+         textureProjectorNode .straightenHorizon (this .rotation);
+
+         invTextureSpaceMatrix .translate (textureProjectorNode .getLocation ());
+         invTextureSpaceMatrix .rotate (this .rotation);
+         invTextureSpaceMatrix .inverse ();
+
+         var
+            width            = textureProjectorNode .getTexture () .getWidth (),
+            height           = textureProjectorNode .getTexture () .getHeight (),
+            nearDistance     = textureProjectorNode .getNearDistance (),
+            farDistance      = textureProjectorNode .getFarDistance (),
+            fieldOfView      = textureProjectorNode .getFieldOfView ();
+
+         Camera .perspective (fieldOfView, nearDistance, farDistance, width, height, this .projectionMatrix);
+
+         if (! textureProjectorNode .getGlobal ())
+            invTextureSpaceMatrix .multLeft (modelMatrix .inverse ());
+
+         this .invTextureSpaceProjectionMatrix .assign (invTextureSpaceMatrix) .multRight (this .projectionMatrix) .multRight (textureProjectorNode .getBiasMatrix ());
+
+         this .projectiveTextureMatrix .assign (cameraSpaceMatrix) .multRight (this .invTextureSpaceProjectionMatrix);
+         this .projectiveTextureMatrixArray .set (this .projectiveTextureMatrix);
+
+         this .modelViewMatrix .multVecMatrix (this .location .assign (textureProjectorNode ._location .getValue ()));
+         this .locationArray .set (this .location);
       },
       setShaderUniforms: function (gl, shaderObject, renderObject)
       {

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

@@ -90,18 +90,10 @@ function (Fields,
             plane      = this .plane,
             localPlane = clipPlane .plane;
 
-         try
-         {
-            plane .normal .assign (localPlane);
-            plane .distanceFromOrigin = -localPlane .w;
+         plane .normal .assign (localPlane);
+         plane .distanceFromOrigin = -localPlane .w;
 
-            plane .multRight (modelViewMatrix);
-         }
-         catch (error)
-         {
-            plane .normal .set (0, 0, 0);
-            plane .distanceFromOrigin = 0;
-         }
+         plane .multRight (modelViewMatrix);
       },
       setShaderUniforms: function (gl, shaderObject)
       {

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

@@ -53,14 +53,12 @@
    "x_ite/Base/FieldDefinitionArray",
    "x_ite/Components/Rendering/X3DColorNode",
    "x_ite/Base/X3DConstants",
-   "standard/Math/Numbers/Vector4",
 ],
 function (Fields,
           X3DFieldDefinition,
           FieldDefinitionArray,
           X3DColorNode,
-          X3DConstants,
-          Vector4)
+          X3DConstants)
 {
 "use strict";
 
@@ -132,37 +130,27 @@ function (Fields,
          {
             const color = this .color;
 
-            for (var index = 0, length = this .length * 3; index < length; index += 3)
+            for (var index = 0, length = Math .min (min, this .length) * 3; index < length; index += 3)
                array .push (color [index], color [index + 1], color [index + 2], 1);
 
-            var index = (this .length - 1) * 3;
+            if (this .length < min)
+            {
+               var index = (this .length - 1) * 3;
 
-            const
-               r = color [index],
-               g = color [index + 1],
-               b = color [index + 2];
+               const
+                  r = color [index],
+                  g = color [index + 1],
+                  b = color [index + 2];
 
-            for (var index = length, length = min * 3; index < length; index += 3)
-               array .push (r, g, b, 1);
+               for (var index = length, length = min * 3; index < length; index += 3)
+                  array .push (r, g, b, 1);
+            }
          }
          else
          {
             for (let index = 0; index < min; ++ index)
                array .push (1, 1, 1, 1);
          }
-      },
-      getVectors: function (array)
-      {
-         const color = this ._color;
-
-         for (var i = 0, length = color .length; i < length; ++ i)
-         {
-            const c = color [i];
-
-            array [i] = new Vector4 (c .r, c .g, c .b, 1);
-         }
-
-         array .length = length;
 
          return array;
       },

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

@@ -53,14 +53,12 @@ define ([
    "x_ite/Base/FieldDefinitionArray",
    "x_ite/Components/Rendering/X3DColorNode",
    "x_ite/Base/X3DConstants",
-   "standard/Math/Numbers/Vector4",
 ],
 function (Fields,
           X3DFieldDefinition,
           FieldDefinitionArray,
           X3DColorNode,
-          X3DConstants,
-          Vector4)
+          X3DConstants)
 {
 "use strict";
 
@@ -134,38 +132,28 @@ function (Fields,
          {
             const color = this .color;
 
-            for (var index = 0, length = this .length * 4; index < length; index += 4)
+            for (var index = 0, length = Math .min (min, this .length) * 4; index < length; index += 4)
                array .push (color [index], color [index + 1], color [index + 2], color [index + 3]);
 
-            var index = (this .length - 1) * 4;
+            if (this .length < min)
+            {
+               var index = (this .length - 1) * 4;
 
-            const
-               r = color [index],
-               g = color [index + 1],
-               b = color [index + 2],
-               a = color [index + 2];
+               const
+                  r = color [index],
+                  g = color [index + 1],
+                  b = color [index + 2],
+                  a = color [index + 2];
 
-            for (var index = length, length = min * 4; index < length; index += 4)
-               array .push (r, g, b, a);
+               for (var index = length, length = min * 4; index < length; index += 4)
+                  array .push (r, g, b, a);
+            }
          }
          else
          {
             for (let index = 0; index < min; ++ index)
                array .push (1, 1, 1, 1);
          }
-      },
-      getVectors: function (array)
-      {
-         const color = this ._color;
-
-         for (var i = 0, length = color .length; i < length; ++ i)
-         {
-            const c = color [i];
-
-            array [i] = new Vector4 (c .r, c .g, c .b, c .a);
-         }
-
-         array .length = length;
 
          return array;
       },

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

@@ -72,6 +72,7 @@ function (Fields,
 
       this .fogCoordNode = null;
       this .colorNode    = null;
+      this .normalNode   = null;
       this .coordNode    = null;
    }
 
@@ -88,6 +89,7 @@ function (Fields,
          new X3DFieldDefinition (X3DConstants .inputOutput,    "attrib",         new Fields .MFNode ()),
          new X3DFieldDefinition (X3DConstants .inputOutput,    "fogCoord",       new Fields .SFNode ()),
          new X3DFieldDefinition (X3DConstants .inputOutput,    "color",          new Fields .SFNode ()),
+         new X3DFieldDefinition (X3DConstants .inputOutput,    "normal",         new Fields .SFNode ()),
          new X3DFieldDefinition (X3DConstants .inputOutput,    "coord",          new Fields .SFNode ()),
       ]),
       getTypeName: function ()
@@ -111,11 +113,13 @@ function (Fields,
          this ._attrib         .addInterest ("set_attrib__",   this);
          this ._fogCoord       .addInterest ("set_fogCoord__", this);
          this ._color          .addInterest ("set_color__",    this);
+         this ._normal         .addInterest ("set_normal__",   this);
          this ._coord          .addInterest ("set_coord__",    this);
 
          this .set_attrib__ ();
          this .set_fogCoord__ ();
          this .set_color__ ();
+         this .set_normal__ ();
          this .set_coord__ ();
       },
       set_attrib__: function ()
@@ -123,7 +127,10 @@ function (Fields,
          const attribNodes = this .getAttrib ();
 
          for (const attribNode of attribNodes)
+         {
             attribNode .removeInterest ("requestRebuild", this);
+            attribNode ._attribute_changed .removeInterest ("updateVertexArrays", this);
+         }
 
          attribNodes .length = 0;
 
@@ -136,7 +143,12 @@ function (Fields,
          }
 
          for (const attribNode of attribNodes)
+         {
             attribNode .addInterest ("requestRebuild", this);
+            attribNode ._attribute_changed .addInterest ("updateVertexArrays", this);
+         }
+
+         this .updateVertexArrays ();
       },
       set_fogCoord__: function ()
       {
@@ -172,6 +184,16 @@ function (Fields,
       {
          this .setTransparent (this .colorNode .getTransparent ());
       },
+      set_normal__: function ()
+      {
+         if (this .normalNode)
+            this .normalNode .removeInterest ("requestRebuild", this);
+
+         this .normalNode = X3DCast (X3DConstants .X3DNormalNode, this ._normal);
+
+         if (this .normalNode)
+            this .normalNode .addInterest ("requestRebuild", this);
+      },
       set_coord__: function ()
       {
          if (this .coordNode)
@@ -242,8 +264,8 @@ function (Fields,
             polylines      = this .getPolylineIndices (),
             colorPerVertex = this ._colorPerVertex .getValue (),
             attribNodes    = this .getAttrib (),
-            numAttrib      = attribNodes .length,
-            attribs        = this .getAttribs (),
+            numAttribNodes = attribNodes .length,
+            attribArrays   = this .getAttribs (),
             fogCoordNode   = this .fogCoordNode,
             colorNode      = this .colorNode,
             coordNode      = this .coordNode,
@@ -269,8 +291,8 @@ function (Fields,
                         i     = polyline [l],
                         index = coordIndex [i];
 
-                     for (let a = 0; a < numAttrib; ++ a)
-                        attribNodes [a] .addValue (index, attribs [a]);
+                     for (let a = 0; a < numAttribNodes; ++ a)
+                        attribNodes [a] .addValue (index, attribArrays [a]);
 
                      if (fogCoordNode)
                         fogCoordNode .addDepth (index, fogDepthArray);