x_ite 5.0.3 → 6.1.0

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

@@ -49,11 +49,15 @@
 
 define ([
    "x_ite/Components/Rendering/X3DGeometryNode",
+   "standard/Math/Geometry/ViewVolume",
+   "standard/Math/Geometry/Box3",
    "standard/Math/Numbers/Vector2",
    "standard/Math/Numbers/Vector3",
    "standard/Math/Numbers/Matrix4",
 ],
 function (X3DGeometryNode,
+          ViewVolume,
+          Box3,
           Vector2,
           Vector3,
           Matrix4)
@@ -77,188 +81,174 @@ function (X3DGeometryNode,
       constructor: X3DLineGeometryNode,
       intersectsLine: (function ()
       {
-         const PICK_DISTANCE_FACTOR = 1 / 300;
-
          const
-            point     = new Vector3 (0, 0, 0),
-            vector    = new Vector3 (0, 0, 0),
-            clipPoint = new Vector3 (0, 0, 0);
-
-         return function (hitRay, clipPlanes, modelViewMatrix, intersections)
+            bbox                      = new Box3 (),
+            min                       = new Vector3 (0, 0, 0),
+            max                       = new Vector3 (0, 0, 0),
+            screenScale1_             = new Vector3 (0, 0, 0),
+            screenScale2_             = new Vector3 (0, 0, 0),
+            point                     = new Vector3 (0, 0, 0),
+            pointSizePoint            = new Vector3 (0, 0, 0),
+            modelViewProjectionMatrix = new Matrix4 (),
+            projected                 = new Vector2 (0, 0),
+            clipPoint                 = new Vector3 (0, 0, 0);
+
+         return function (hitRay, renderObject, invModelViewMatrix, appearanceNode, intersections)
          {
-            if (this .intersectsBBox (hitRay, 1))
+            const
+               modelViewMatrix     = renderObject .getModelViewMatrix () .get (),
+               viewport            = renderObject .getViewVolume () .getViewport (),
+               extents             = bbox .assign (this .getBBox ()) .multRight (modelViewMatrix) .getExtents (min, max),
+               pointPropertiesNode = appearanceNode .getPointProperties (),
+               pointSize1          = Math .max (1.5, pointPropertiesNode .getPointSize (min) / 2),
+               screenScale1        = renderObject .getViewpoint () .getScreenScale (min, viewport, screenScale1_), // in m/px
+               offsets1            = invModelViewMatrix .multDirMatrix (screenScale1 .multiply (pointSize1)),
+               pointSize2          = Math .max (1.5, pointPropertiesNode .getPointSize (max) / 2),
+               screenScale2        = renderObject .getViewpoint () .getScreenScale (max, viewport, screenScale2_), // in m/px
+               offsets2            = invModelViewMatrix .multDirMatrix (screenScale2 .multiply (pointSize2));
+
+            if (this .intersectsBBox (hitRay, offsets1 .abs () .max (offsets2 .abs ())))
             {
-               const vertices = this .getVertices ();
+               const
+                  pointer          = renderObject .getBrowser () .getPointer (),
+                  projectionMatrix = renderObject .getProjectionMatrix () .get (),
+                  clipPlanes       = renderObject .getLocalObjects (),
+                  vertices         = this .getVertices (),
+                  numVertices      = vertices .length;
 
-               for (let i = 0, length = vertices .length; i < length; i += 4)
+               modelViewProjectionMatrix .assign (modelViewMatrix) .multRight (projectionMatrix);
+
+               for (let i = 0; i < numVertices; i += 4)
                {
                   point .set (vertices [i + 0], vertices [i + 1], vertices [i + 2]);
 
-                  if (hitRay .getPerpendicularVectorToPoint (point, vector) .abs () < hitRay .point .distance (point) * PICK_DISTANCE_FACTOR)
+                  ViewVolume .projectPointMatrix (point, modelViewProjectionMatrix, viewport, projected);
+
+                  const pointSize1_2 = Math .max (1.5, pointPropertiesNode .getPointSize (modelViewMatrix .multVecMatrix (pointSizePoint .assign (point))) / 2);
+
+                  if (projected .distance (pointer) <= pointSize1_2)
                   {
-                     if (this .isClipped (modelViewMatrix .multVecMatrix (clipPoint .assign (point)), clipPlanes))
-                        continue;
+                     if (clipPlanes .length)
+                     {
+                        if (this .isClipped (modelViewMatrix .multVecMatrix (clipPoint .assign (point)), clipPlanes))
+                           continue;
+                     }
 
-                     intersections .push ({ texCoord: new Vector2 (0, 0), normal: new Vector3 (0, 0, 0), point: point .copy () });
-                     return true;
+                     const
+                        texCoord = pointer .copy () .subtract (projected) .divide (pointSize1_2) .add (Vector2 .One) .divide (2),
+                        normal   = modelViewMatrix .submatrix .transpose () .z .copy () .normalize ();
+
+                     intersections .push ({ texCoord: texCoord, normal: normal, point: point .copy () });
                   }
                }
             }
 
-            return false;
+            return intersections .length;
          };
       })(),
+      intersectsLineWithGeometry: function ()
+      {
+         return false;
+      },
       intersectsBox: function (box, clipPlanes, modelViewMatrix)
       {
          return false;
       },
+      buildTexCoords: function ()
+      { },
       display: function (gl, context)
       {
-         try
+         const
+            browser        = context .browser,
+            appearanceNode = context .shapeNode .getAppearance (),
+            shaderNode     = appearanceNode .getShader () || browser .getPointShader (),
+            blendModeNode  = appearanceNode .getBlendMode (),
+            attribNodes    = this .getAttrib (),
+            attribBuffers  = this .getAttribBuffers ();
+
+         if (shaderNode .isValid ())
          {
-            const
-               browser        = context .browser,
-               appearanceNode = context .shapeNode .getAppearance (),
-               shaderNode     = appearanceNode .shaderNode || browser .getPointShader ();;
+            if (blendModeNode)
+               blendModeNode .enable (gl);
 
-            if (shaderNode .getValid ())
-            {
-               const
-                  blendModeNode = appearanceNode .blendModeNode,
-                  attribNodes   = this .attribNodes,
-                  attribBuffers = this .attribBuffers;
-
-               if (blendModeNode)
-                  blendModeNode .enable (gl);
+            // Setup shader.
 
-               // Setup shader.
+            shaderNode .enable (gl);
+            shaderNode .setLocalUniforms (gl, context);
 
-               shaderNode .enable (gl);
-               shaderNode .setLocalUniforms (gl, context);
-
-               // Setup vertex attributes.
+            // Setup vertex attributes.
 
+            if (this .vertexArrayObject .enable (gl, shaderNode))
+            {
                for (let i = 0, length = attribNodes .length; i < length; ++ i)
                   attribNodes [i] .enable (gl, shaderNode, attribBuffers [i]);
 
                if (this .fogCoords)
-                  shaderNode .enableFogDepthAttribute (gl, this .fogDepthBuffer);
+                  shaderNode .enableFogDepthAttribute (gl, this .fogDepthBuffer, 0, 0);
 
                if (this .colorMaterial)
-                  shaderNode .enableColorAttribute (gl, this .colorBuffer);
-
-               if (this .getMultiTexCoords () .length)
-                  shaderNode .enableTexCoordAttribute (gl, this .texCoordBuffers, true);
-
-               shaderNode .enableVertexAttribute (gl, this .vertexBuffer);
-
-               gl .drawArrays (this .primitiveMode, 0, this .vertexCount);
+                  shaderNode .enableColorAttribute (gl, this .colorBuffer, 0, 0);
 
-               for (const attribNode of attribNodes)
-                  attribNode .disable (gl, shaderNode);
-
-               if (this .fogCoords)
-                  shaderNode .disableFogDepthAttribute (gl);
-
-               if (this .colorMaterial)
-                  shaderNode .disableColorAttribute (gl);
+               shaderNode .enableVertexAttribute (gl, this .vertexBuffer, 0, 0);
+            }
 
-               if (this .getMultiTexCoords () .length)
-                  shaderNode .disableTexCoordAttribute (gl);
+            gl .drawArrays (this .primitiveMode, 0, this .vertexCount);
 
-               if (blendModeNode)
-                  blendModeNode .disable (gl);
-            }
-         }
-         catch (error)
-         {
-            // Catch error from setLocalUniforms.
-            console .error (error);
+            if (blendModeNode)
+               blendModeNode .disable (gl);
          }
       },
-      displayParticles: function (gl, context, particles, numParticles)
+      displayParticles: function (gl, context, particleSystem)
       {
-         try
+         const
+            browser        = context .browser,
+            appearanceNode = context .shapeNode .getAppearance (),
+            shaderNode     = appearanceNode .getShader () || browser .getPointShader (),
+            blendModeNode  = appearanceNode .getBlendMode (),
+            attribNodes    = this .getAttrib (),
+            attribBuffers  = this .getAttribBuffers ();
+
+         if (shaderNode .isValid ())
          {
-            const
-               browser        = context .browser,
-               appearanceNode = context .shapeNode .getAppearance (),
-               shaderNode     = appearanceNode .shaderNode || this .getShader (browser);
+            if (blendModeNode)
+               blendModeNode .enable (gl);
 
-            if (shaderNode .getValid ())
-            {
-               const
-                  blendModeNode = appearanceNode .blendModeNode,
-                  attribNodes   = this .attribNodes,
-                  attribBuffers = this .attribBuffers;
+            // Setup shader.
 
-               if (blendModeNode)
-                  blendModeNode .enable (gl);
+            shaderNode .enable (gl);
+            shaderNode .setLocalUniforms (gl, context);
 
-               // Setup shader.
+            // Setup vertex attributes.
 
-               shaderNode .enable (gl);
-               shaderNode .setLocalUniforms (gl, context);
+            const outputParticles = particleSystem .outputParticles;
 
-               // Setup vertex attributes.
+            if (outputParticles .vertexArrayObject .update (this .updateParticles) .enable (gl, shaderNode))
+            {
+               const particleStride = particleSystem .particleStride;
+
+               shaderNode .enableParticleAttribute (gl, outputParticles, particleStride, particleSystem .particleOffset, 1);
+               shaderNode .enableParticleMatrixAttribute (gl, outputParticles, particleStride, particleSystem .matrixOffset, 1);
 
                for (let i = 0, length = attribNodes .length; i < length; ++ i)
                   attribNodes [i] .enable (gl, shaderNode, attribBuffers [i]);
 
                if (this .fogCoords)
-                  shaderNode .enableFogDepthAttribute (gl, this .fogDepthBuffer);
+                  shaderNode .enableFogDepthAttribute (gl, this .fogDepthBuffer, 0, 0);
 
                if (this .colorMaterial)
-                  shaderNode .enableColorAttribute (gl, this .colorBuffer);
-
-               if (this .getMultiTexCoords () .length)
-                  shaderNode .enableTexCoordAttribute (gl, this .texCoordBuffers);
-
-               shaderNode .enableVertexAttribute   (gl, this .vertexBuffer);
-
-               // Wireframes are always solid so only one drawing call is needed.
-
-               const
-                  modelViewMatrix = context .modelViewMatrix,
-                  x               = modelViewMatrix [12],
-                  y               = modelViewMatrix [13],
-                  z               = modelViewMatrix [14],
-                  primitiveMode   = this .primitiveMode;
+                  shaderNode .enableColorAttribute (gl, this .colorBuffer, 0, 0);
 
-               for (let p = 0; p < numParticles; ++ p)
-               {
-                  const particle = particles [p];
-
-                  modelViewMatrix [12] = x;
-                  modelViewMatrix [13] = y;
-                  modelViewMatrix [14] = z;
-
-                  Matrix4 .prototype .translate .call (modelViewMatrix, particle .position);
-
-                  shaderNode .setParticle (gl, particle, modelViewMatrix);
-
-                  gl .drawArrays (primitiveMode, 0, this .vertexCount);
-               }
-
-               for (const attribNode of attribNodes)
-                  attribNode .disable (gl, shaderNode);
+               shaderNode .enableVertexAttribute (gl, this .vertexBuffer, 0, 0);
 
-               if (this .fogCoords)
-                  shaderNode .disableFogDepthAttribute (gl);
+               this .updateParticles = false;
+            }
 
-               if (this .colorMaterial)
-                  shaderNode .disableColorAttribute (gl);
+            // Wireframes are always solid so only one drawing call is needed.
 
-               shaderNode .disableTexCoordAttribute (gl);
+            gl .drawArraysInstanced (this .primitiveMode, 0, this .vertexCount, particleSystem .numParticles);
 
-               if (blendModeNode)
-                  blendModeNode .disable (gl);
-            }
-         }
-         catch (error)
-         {
-            // Catch error from setLocalUniforms.
-            console .error (error);
+            if (blendModeNode)
+               blendModeNode .disable (gl);
          }
       },
    });

package/src/x_ite/Components/RigidBodyPhysics/DoubleAxisHingeJoint.js

@@ -240,30 +240,23 @@ function ($,
 
          return function ()
          {
-            try
-            {
-               if (this .outputs .body1AnchorPoint)
-                  this ._body1AnchorPoint = this .getBody1 () .getMatrix () .multVecMatrix (this .getInitialInverseMatrix1 () .multVecMatrix (localAnchorPoint1 .assign (this .localAnchorPoint1)));
+            if (this .outputs .body1AnchorPoint)
+               this ._body1AnchorPoint = this .getBody1 () .getMatrix () .multVecMatrix (this .getInitialInverseMatrix1 () .multVecMatrix (localAnchorPoint1 .assign (this .localAnchorPoint1)));
 
-               if (this .outputs .body1Axis)
-                  this ._body1Axis = this .getInitialInverseMatrix1 () .multDirMatrix (this .getBody1 () .getMatrix () .multDirMatrix (localAxis1 .assign (this .localAxis1))) .normalize ();
+            if (this .outputs .body1Axis)
+               this ._body1Axis = this .getInitialInverseMatrix1 () .multDirMatrix (this .getBody1 () .getMatrix () .multDirMatrix (localAxis1 .assign (this .localAxis1))) .normalize ();
 
-               if (this .outputs .hinge1Angle)
-               {
-                  var lastAngle  = this ._hinge1Angle .getValue ();
+            if (this .outputs .hinge1Angle)
+            {
+               var lastAngle  = this ._hinge1Angle .getValue ();
 
-                  difference .assign (this .getInitialInverseMatrix1 ()) .multRight (this .getBody1 () .getMatrix ());
-                  difference .get (null, rotation);
+               difference .assign (this .getInitialInverseMatrix1 ()) .multRight (this .getBody1 () .getMatrix ());
+               difference .get (null, rotation);
 
-                  this ._hinge1Angle = rotation .angle;
+               this ._hinge1Angle = rotation .angle;
 
-                  if (this .outputs .angleRate)
-                     this ._hinge1AngleRate = (this ._hinge1Angle .getValue () - lastAngle) * this .getBrowser () .getCurrentFrameRate ();
-               }
-            }
-            catch (error)
-            {
-               // matrix .get
+               if (this .outputs .angleRate)
+                  this ._hinge1AngleRate = (this ._hinge1Angle .getValue () - lastAngle) * this .getBrowser () .getCurrentFrameRate ();
             }
          };
       })(),
@@ -277,30 +270,23 @@ function ($,
 
          return function ()
          {
-            try
-            {
-               if (this .outputs .body2AnchorPoint)
-                  this ._body2AnchorPoint = this .getBody2 () .getMatrix () .multVecMatrix (this .getInitialInverseMatrix2 () .multVecMatrix (localAnchorPoint2 .assign (this .localAnchorPoint2)));
+            if (this .outputs .body2AnchorPoint)
+               this ._body2AnchorPoint = this .getBody2 () .getMatrix () .multVecMatrix (this .getInitialInverseMatrix2 () .multVecMatrix (localAnchorPoint2 .assign (this .localAnchorPoint2)));
 
-               if (this .outputs .body2Axis)
-                  this ._body2Axis = this .getInitialInverseMatrix2 () .multDirMatrix (this .getBody2 () .getMatrix () .multDirMatrix (localAxis2 .assign (this .localAxis2))) .normalize ();
+            if (this .outputs .body2Axis)
+               this ._body2Axis = this .getInitialInverseMatrix2 () .multDirMatrix (this .getBody2 () .getMatrix () .multDirMatrix (localAxis2 .assign (this .localAxis2))) .normalize ();
 
-               if (this .outputs .hinge2Angle)
-               {
-                  var lastAngle  = this ._hinge2Angle .getValue ();
+            if (this .outputs .hinge2Angle)
+            {
+               var lastAngle  = this ._hinge2Angle .getValue ();
 
-                  difference .assign (this .getInitialInverseMatrix2 ()) .multRight (this .getBody2 () .getMatrix ());
-                  difference .get (null, rotation);
+               difference .assign (this .getInitialInverseMatrix2 ()) .multRight (this .getBody2 () .getMatrix ());
+               difference .get (null, rotation);
 
-                  this ._hinge2Angle = rotation .angle;
+               this ._hinge2Angle = rotation .angle;
 
-                  if (this .outputs .angleRate)
-                     this ._hinge2AngleRate = (this ._hinge2Angle .getValue () - lastAngle) * this .getBrowser () .getCurrentFrameRate ();
-               }
-            }
-            catch (error)
-            {
-               // matrix .get
+               if (this .outputs .angleRate)
+                  this ._hinge2AngleRate = (this ._hinge2Angle .getValue () - lastAngle) * this .getBrowser () .getCurrentFrameRate ();
             }
          };
       })(),

package/src/x_ite/Components/RigidBodyPhysics/SingleAxisHingeJoint.js

@@ -232,27 +232,20 @@ function ($,
 
          return function ()
          {
-            try
-            {
-               if (this .outputs .body2AnchorPoint)
-                  this ._body2AnchorPoint = this .getBody2 () .getMatrix () .multVecMatrix (this .getInitialInverseMatrix2 () .multVecMatrix (localAnchorPoint2 .assign (this .localAnchorPoint2)));
+            if (this .outputs .body2AnchorPoint)
+               this ._body2AnchorPoint = this .getBody2 () .getMatrix () .multVecMatrix (this .getInitialInverseMatrix2 () .multVecMatrix (localAnchorPoint2 .assign (this .localAnchorPoint2)));
 
-               if (this .outputs .angle)
-               {
-                  var lastAngle  = this ._angle .getValue ();
+            if (this .outputs .angle)
+            {
+               var lastAngle  = this ._angle .getValue ();
 
-                  difference .assign (this .getInitialInverseMatrix2 ()) .multRight (this .getBody2 () .getMatrix ());
-                  difference .get (null, rotation);
+               difference .assign (this .getInitialInverseMatrix2 ()) .multRight (this .getBody2 () .getMatrix ());
+               difference .get (null, rotation);
 
-                  this ._angle = rotation .angle;
+               this ._angle = rotation .angle;
 
-                  if (this .outputs .angleRate)
-                     this ._angleRate = (this ._angle .getValue () - lastAngle) * this .getBrowser () .getCurrentFrameRate ();
-               }
-            }
-            catch (error)
-            {
-               // matrix .get
+               if (this .outputs .angleRate)
+                  this ._angleRate = (this ._angle .getValue () - lastAngle) * this .getBrowser () .getCurrentFrameRate ();
             }
          };
       })(),

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

@@ -75,7 +75,8 @@ function (Fields,
 
       this .addType (X3DConstants .ComposedShader);
 
-      this .loadSensor = new LoadSensor (executionContext);
+      this .loadSensor                = new LoadSensor (executionContext);
+      this .transformFeedbackVaryings = [ ];
    }
 
    ComposedShader .prototype = Object .assign (Object .create (X3DShaderNode .prototype),
@@ -125,39 +126,27 @@ function (Fields,
       },
       addUserDefinedField: function (accessType, name, field)
       {
-         const gl = this .getBrowser () .getContext ();
-
-         if (this .isInitialized () && this .isLive () .getValue () && this .getValid ())
-         {
-            this .enable (gl);
+         if (this .isInitialized () && this .isLive () .getValue () && this .isValid ())
             this .removeShaderFields ();
-         }
 
          X3DShaderNode .prototype .addUserDefinedField .call (this, accessType, name, field);
 
-         if (this .isInitialized () && this .isLive () .getValue () && this .getValid ())
-         {
-            this .enable (gl);
-            this .addShaderFields ();
-         }
+         if (this .isInitialized () && this .isLive () .getValue () && this .isValid ())
+            this .addShaderFields (this .program);
       },
       removeUserDefinedField: function (name)
       {
-         const gl = this .getBrowser () .getContext ();
-
-         if (this .isInitialized () && this .isLive () .getValue () && this .getValid ())
-         {
-            this .enable (gl);
+         if (this .isInitialized () && this .isLive () .getValue () && this .isValid ())
             this .removeShaderFields ();
-         }
 
          X3DShaderNode .prototype .removeUserDefinedField .call (this, name);
 
-         if (this .isInitialized () && this .isLive () .getValue () && this .getValid ())
-         {
-            this .enable (gl);
-            this .addShaderFields ();
-         }
+         if (this .isInitialized () && this .isLive () .getValue () && this .isValid ())
+            this .addShaderFields (this .program);
+      },
+      setTransformFeedbackVaryings: function (value)
+      {
+         this .transformFeedbackVaryings = value;
       },
       getProgram: function ()
       {
@@ -165,23 +154,15 @@ function (Fields,
       },
       set_live__: function ()
       {
-         const gl = this .getBrowser () .getContext ();
-
          if (this .isLive () .getValue ())
          {
-            if (this .getValid ())
-            {
-               this .enable (gl);
-               this .addShaderFields ();
-            }
+            if (this .isValid ())
+               this .addShaderFields (this .program);
          }
          else
          {
-            if (this .getValid ())
-            {
-               this .enable (gl);
+            if (this .isValid ())
                this .removeShaderFields ();
-            }
          }
       },
       set_loaded__: function ()
@@ -192,11 +173,11 @@ function (Fields,
                gl      = this .getBrowser () .getContext (),
                program = gl .createProgram ();
 
-            let valid = 0;
-
-            if (this .getValid ())
+            if (this .isValid ())
                this .removeShaderFields ();
 
+            gl .deleteProgram (this .program);
+
             this .program = program;
 
             for (const node of this ._parts)
@@ -204,38 +185,18 @@ function (Fields,
                const partNode = X3DCast (X3DConstants .ShaderPart, node);
 
                if (partNode)
-               {
-                  valid += partNode .isValid ();
                   gl .attachShader (program, partNode .getShader ());
-               }
             }
 
-            if (valid)
-            {
-               this .bindAttributeLocations (gl, program);
-
-               gl .linkProgram (program);
+            if (this .transformFeedbackVaryings .length)
+               gl .transformFeedbackVaryings (program, this .transformFeedbackVaryings, gl .INTERLEAVED_ATTRIBS);
 
-               valid = gl .getProgramParameter (program, gl .LINK_STATUS);
-            }
+            gl .linkProgram (program);
 
-            if (valid)
+            if (gl .getProgramParameter (program, gl .LINK_STATUS))
             {
-               gl .useProgram (this .program);
-
-               // Initialize uniform variables and attributes
-               if (this .getDefaultUniforms ())
-               {
-                  // Setup user-defined fields.
-                  this .addShaderFields ();
-               }
-               else
-               {
-                  valid = false;
-               }
-
-               // Debug, print complete shader info and statistics.
-               // this .printProgramInfo ();
+               this .getDefaultUniformsAndAttributes (program);
+               this .setValid (true);
             }
             else
             {
@@ -243,9 +204,12 @@ function (Fields,
                {
                   console .warn ("Couldn't initialize " + this .getTypeName () + " '" + this .getName () + "': " + gl .getProgramInfoLog (program));
                }
+
+               this .setValid (false);
             }
 
-            this .setValid (!! valid);
+            if (this .isValid ())
+               this .addShaderFields (this .program);
          }
          else
          {
@@ -254,23 +218,19 @@ function (Fields,
       },
       set_field__: function (field)
       {
-         const gl = this .getBrowser () .getContext ();
-
-         gl .useProgram (this .program);
-
-         X3DProgrammableShaderObject .prototype .set_field__ .call (this, field);
+         if (this .isValid ())
+            X3DProgrammableShaderObject .prototype .set_field__ .call (this, field, this .program);
       },
       setGlobalUniforms: function (gl, renderObject, cameraSpaceMatrixArray, projectionMatrixArray, viewportArray)
       {
-         gl .useProgram (this .program);
-
-         X3DProgrammableShaderObject .prototype .setGlobalUniforms .call (this, gl, renderObject, cameraSpaceMatrixArray, projectionMatrixArray, viewportArray);
+         if (this .isValid ())
+         {
+            X3DProgrammableShaderObject .prototype .setGlobalUniforms .call (this, gl, this .program, renderObject, cameraSpaceMatrixArray, projectionMatrixArray, viewportArray);
+         }
       },
       enable: function (gl)
       {
-         gl .useProgram (this .program);
-
-         X3DProgrammableShaderObject .prototype .enable .call (this, gl);
+         X3DProgrammableShaderObject .prototype .enable .call (this, gl, this .program);
       },
    });
 

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

@@ -96,17 +96,18 @@ function (Fields,
       {
          X3DVertexAttributeNode .prototype .initialize .call (this);
 
-         this ._numComponents .addInterest ("set_numComponents", this);
-         this ._value         .addInterest ("set_value",         this);
+         this ._numComponents .addInterest ("set_numComponents__", this);
+         this ._numComponents .addInterest ("set_attribute__",     this);
+         this ._value         .addInterest ("set_value__",         this);
 
-         this .set_numComponents ();
-         this .set_value ();
+         this .set_numComponents__ ();
+         this .set_value__ ();
       },
-      set_numComponents: function ()
+      set_numComponents__: function ()
       {
          this .numComponents = Algorithm .clamp (this ._numComponents .getValue (), 1, 4);
       },
-      set_value: function ()
+      set_value__: function ()
       {
          this .value  = this ._value .getValue ();
          this .length = this ._value .length;
@@ -140,11 +141,7 @@ function (Fields,
       },
       enable: function (gl, shaderNode, buffer)
       {
-         shaderNode .enableFloatAttrib (gl, this ._name .getValue (), buffer, this .numComponents);
-      },
-      disable: function (gl, shaderNode)
-      {
-         shaderNode .disableFloatAttrib (gl, this ._name .getValue ());
+         shaderNode .enableFloatAttrib (gl, this ._name .getValue (), buffer, this .numComponents, 0, 0);
       },
    });