x_ite 5.0.2 → 6.0.0

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

@@ -52,11 +52,13 @@ define ([
    "x_ite/Base/X3DConstants",
    "x_ite/Components/Navigation/OrthoViewpoint",
    "standard/Math/Numbers/Matrix3",
+   "standard/Math/Numbers/Matrix4",
 ],
 function (X3DCast,
           X3DConstants,
           OrthoViewpoint,
-          Matrix3)
+          Matrix3,
+          Matrix4)
 {
 "use strict";
 
@@ -66,6 +68,8 @@ function (X3DCast,
    {
       this .addType (X3DConstants .X3DProgrammableShaderObject);
 
+      this .uniforms = [ ];
+
       this .x3d_ClipPlane                           = [ ];
       this .x3d_LightType                           = [ ];
       this .x3d_LightOn                             = [ ];
@@ -106,7 +110,7 @@ function (X3DCast,
       this .numProjectiveTextures       = 0;
       this .numGlobalProjectiveTextures = 0;
       this .projectiveTextureNodes      = [ ];
-      this .textures                    = new Map ();
+      this .textures                    = new Set ();
    }
 
    X3DProgrammableShaderObject .prototype =
@@ -124,18 +128,26 @@ function (X3DCast,
       {
          return true;
       },
-      bindAttributeLocations: function (gl, program)
+      setUniforms: function (value)
       {
-         gl .bindAttribLocation (program, 0, "x3d_Vertex");
+         this .uniforms = value;
       },
-      getDefaultUniforms: function ()
+      getDefaultUniformsAndAttributes: function (program)
       {
          // Get uniforms and attributes.
 
          const
             browser = this .getBrowser (),
-            gl      = browser .getContext (),
-            program = this .getProgram ();
+            gl      = browser .getContext ();
+
+         gl .useProgram (program);
+
+         for (const name of this .uniforms)
+            this [name] = gl .getUniformLocation (program, name);
+
+         /*
+          * Uniforms.
+          */
 
          this .x3d_LogarithmicFarFactor1_2 = gl .getUniformLocation (program, "x3d_LogarithmicFarFactor1_2");
 
@@ -162,6 +174,7 @@ function (X3DCast,
 
          this .x3d_LinePropertiesApplied              = gl .getUniformLocation (program, "x3d_LineProperties.applied");
          this .x3d_LinePropertiesLinewidthScaleFactor = this .getUniformLocation (gl, program, "x3d_LineProperties.linewidthScaleFactor", "x3d_LinewidthScaleFactor");
+         this .x3d_LineStippleScale                   = gl .getUniformLocation (program, "x3d_LineProperties.lineStippleScale");
          this .x3d_LinePropertiesLinetype             = gl .getUniformLocation (program, "x3d_LineProperties.linetype");
 
          this .x3d_FillPropertiesFilled     = gl .getUniformLocation (program, "x3d_FillProperties.filled");
@@ -233,6 +246,8 @@ function (X3DCast,
          this .x3d_NumProjectiveTextures = gl .getUniformLocation (program, "x3d_NumProjectiveTextures");
          this .x3d_MultiTextureColor     = gl .getUniformLocation (program, "x3d_MultiTextureColor");
 
+         this .x3d_TexCoord .length = 0;
+
          for (let i = 0; i < this .x3d_MaxTextures; ++ i)
          {
             this .x3d_Textures [i] = {
@@ -255,23 +270,70 @@ function (X3DCast,
             this .x3d_ProjectiveTextureLocation [i] = gl .getUniformLocation (program, "x3d_ProjectiveTextureLocation[" + i + "]");
 
             this .x3d_TextureMatrix [i] = gl .getUniformLocation (program, "x3d_TextureMatrix[" + i + "]");
-            this .x3d_TexCoord [i]      = this .getAttribLocation (gl, program, "x3d_TexCoord" + i, i ? "" : "x3d_TexCoord");
+
+            // Attribute
+
+            const x3d_TexCoord = this .getAttribLocation (gl, program, "x3d_TexCoord" + i, i ? "" : "x3d_TexCoord");
+
+            if (x3d_TexCoord !== -1)
+               this .x3d_TexCoord .push ([i, x3d_TexCoord]);
          }
 
+         this .x3d_TexCoordRamp = gl .getUniformLocation (program, "x3d_TexCoordRamp");
+
          this .x3d_Viewport          = gl .getUniformLocation (program, "x3d_Viewport");
          this .x3d_ProjectionMatrix  = gl .getUniformLocation (program, "x3d_ProjectionMatrix");
          this .x3d_ModelViewMatrix   = gl .getUniformLocation (program, "x3d_ModelViewMatrix");
          this .x3d_NormalMatrix      = gl .getUniformLocation (program, "x3d_NormalMatrix");
          this .x3d_CameraSpaceMatrix = gl .getUniformLocation (program, "x3d_CameraSpaceMatrix");
 
-         this .x3d_FogDepth = gl .getAttribLocation (program, "x3d_FogDepth");
-         this .x3d_Color    = gl .getAttribLocation (program, "x3d_Color");
-         this .x3d_Normal   = gl .getAttribLocation (program, "x3d_Normal");
-         this .x3d_Vertex   = gl .getAttribLocation (program, "x3d_Vertex");
+         /*
+          * Attributes.
+          */
+
+         const attributes = [
+            "FogDepth",
+            "Color",
+            "Normal",
+            "Vertex",
+            "Particle",
+            "ParticleMatrix",
+         ];
+
+         for (const name of attributes)
+         {
+            const attribute = gl .getAttribLocation (program, `x3d_${name}`);
 
-         this .x3d_ParticleId          = gl .getUniformLocation (program, "x3d_Particle.id");
-         this .x3d_ParticleLife        = gl .getUniformLocation (program, "x3d_Particle.life");
-         this .x3d_ParticleElapsedTime = gl .getUniformLocation (program, "x3d_Particle.elapsedTime");
+            this [`x3d_${name}`] = attribute;
+
+            if (attribute < 0)
+            {
+               this [`enable${name}Attribute`]            = Function .prototype;
+               this [`${lcfirst (name)}AttributeDivisor`] = Function .prototype;
+            }
+            else
+            {
+               delete this [`enable${name}Attribute`];
+               delete this [`${lcfirst (name)}AttributeDivisor`];
+            }
+         }
+
+         if (this .x3d_TexCoord .length === 0)
+         {
+            this .enableTexCoordAttribute  = Function .prototype;
+            this .texCoordAttributeDivisor = Function .prototype;
+         }
+         else
+         {
+            delete this .enableTexCoordAttribute;
+            delete this .texCoordAttributeDivisor;
+         }
+
+         /*
+          * Fill uniforms with defaults.
+          */
+
+         gl .uniform1f (this .x3d_LineStippleScale, browser .getLineStippleScale ());
 
          // Fill special uniforms with default values, textures for units are created in X3DTexturingContext.
 
@@ -306,63 +368,19 @@ function (X3DCast,
                gl .uniform1i (uniform, browser .getDefaultTexture2DUnit ());
          }
 
-         // Return true if valid, otherwise false.
+         gl .uniform1i  (this .x3d_TexCoordRamp, browser .getDefaultTexture2DUnit ());
 
-         if (this .x3d_FogDepth < 0)
-         {
-            this .enableFogDepthAttribute  = Function .prototype;
-            this .disableFogDepthAttribute = Function .prototype;
-         }
-         else
-         {
-            delete this .enableFogDepthAttribute;
-            delete this .disableFogDepthAttribute;
-         }
+         /*
+          * Check x3d_Vertex.
+          */
 
-         if (this .x3d_Color < 0)
-         {
-            this .enableColorAttribute  = Function .prototype;
-            this .disableColorAttribute = Function .prototype;
-         }
-         else
-         {
-            delete this .enableColorAttribute;
-            delete this .disableColorAttribute;
-         }
-
-         if (this .x3d_TexCoord .some (function (location) { return location >= 0; }))
-         {
-            delete this .enableTexCoordAttribute;
-            delete this .disableTexCoordAttribute;
-         }
-         else
-         {
-            this .enableTexCoordAttribute  = Function .prototype;
-            this .disableTexCoordAttribute = Function .prototype;
-         }
-
-         if (this .x3d_Normal < 0)
-         {
-            this .enableNormalAttribute  = Function .prototype;
-            this .disableNormalAttribute = Function .prototype;
-         }
-         else
-         {
-            delete this .enableNormalAttribute;
-            delete this .disableNormalAttribute;
-         }
-
-         if (this .x3d_Vertex < 0)
-         {
-            if (gl .getVersion () >= 2)
-               console .warn ("Missing »in vec4 x3d_Vertex;«.");
-            else
-               console .warn ("Missing »attribute vec4 x3d_Vertex;«.");
-
-            return false;
-         }
-
-         return true;
+         // if (this .x3d_Vertex < 0)
+         // {
+         //    if (gl .getVersion () >= 2)
+         //      console .warn ("Missing »in vec4 x3d_Vertex;«.");
+         //    else
+         //       console .warn ("Missing »attribute vec4 x3d_Vertex;«.");
+         // }
       },
       getUniformLocation: function (gl, program, name, depreciated)
       {
@@ -414,11 +432,11 @@ function (X3DCast,
 
          return -1;
       },
-      addShaderFields: function ()
+      addShaderFields: function (program)
       {
-         const
-            gl      = this .getBrowser () .getContext (),
-            program = this .getProgram ();
+         const gl = this .getBrowser () .getContext ();
+
+         gl .useProgram (program);
 
          this .textures .clear ();
 
@@ -528,7 +546,7 @@ function (X3DCast,
 
                field .addInterest ("set_field__", this);
 
-               this .set_field__ (field);
+               this .set_field__ (field, program);
             }
          }
       },
@@ -541,12 +559,14 @@ function (X3DCast,
       {
          const matrix3 = new Matrix3 ();
 
-         return function (field)
+         return function (field, program)
          {
             const
                gl       = this .getBrowser () .getContext (),
                location = field [_uniformLocation];
 
+            gl .useProgram (program);
+
             if (location)
             {
                switch (field .getType ())
@@ -619,11 +639,16 @@ function (X3DCast,
 
                      if (texture)
                      {
-                        this .textures .set (location, { name: field .getName (), texture: texture } );
-                        return;
+                        location .name    = field .getName ();
+                        location .texture = texture;
+
+                        this .textures .add (location);
+                     }
+                     else
+                     {
+                        this .textures .delete (location);
                      }
 
-                     this .textures .delete (location);
                      return;
                   }
                   case X3DConstants .SFRotation:
@@ -789,14 +814,20 @@ function (X3DCast,
                   {
                      const locations = location .locations;
 
-                     for (const node of field)
+                     for (let i = 0, length = field .length; i < length; ++ i)
                      {
-                        const texture = X3DCast (X3DConstants .X3DTextureNode, node);
+                        const texture = X3DCast (X3DConstants .X3DTextureNode, field [i]);
 
                         if (texture)
                         {
-                           this .textures .set (locations [i], { name: field .getName (), texture: texture } );
-                           continue;
+                           locations [i] .name    = field .getName ();
+                           locations [i] .texture = texture;
+
+                           this .textures .add (locations [i]);
+                        }
+                        else
+                        {
+                           this .textures .delete (locations [i]);
                         }
                      }
 
@@ -962,10 +993,12 @@ function (X3DCast,
          gl .uniform1i (this .x3d_NumLights,             Math .min (this .numLights,             this .x3d_MaxLights));
          gl .uniform1i (this .x3d_NumProjectiveTextures, Math .min (this .numProjectiveTextures, this .x3d_MaxTextures));
       },
-      setGlobalUniforms: function (gl, renderObject, cameraSpaceMatrixArray, projectionMatrixArray, viewportArray)
+      setGlobalUniforms: function (gl, program, renderObject, cameraSpaceMatrixArray, projectionMatrixArray, viewportArray)
       {
          const globalObjects = renderObject .getGlobalObjects ();
 
+         gl .useProgram (program);
+
          // Set viewport
 
          gl .uniform4iv (this .x3d_Viewport, viewportArray);
@@ -1074,37 +1107,30 @@ function (X3DCast,
 
          return function (modelViewMatrix)
          {
-            try
-            {
-               normalMatrix [0] = modelViewMatrix [0], normalMatrix [3] = modelViewMatrix [1], normalMatrix [6] = modelViewMatrix [ 2],
-               normalMatrix [1] = modelViewMatrix [4], normalMatrix [4] = modelViewMatrix [5], normalMatrix [7] = modelViewMatrix [ 6],
-               normalMatrix [2] = modelViewMatrix [8], normalMatrix [5] = modelViewMatrix [9], normalMatrix [8] = modelViewMatrix [10];
-
-               Matrix3 .prototype .inverse .call (normalMatrix);
+            normalMatrix [0] = modelViewMatrix [0]; normalMatrix [3] = modelViewMatrix [1]; normalMatrix [6] = modelViewMatrix [ 2];
+            normalMatrix [1] = modelViewMatrix [4]; normalMatrix [4] = modelViewMatrix [5]; normalMatrix [7] = modelViewMatrix [ 6];
+            normalMatrix [2] = modelViewMatrix [8]; normalMatrix [5] = modelViewMatrix [9]; normalMatrix [8] = modelViewMatrix [10];
 
-               return normalMatrix;
-            }
-            catch (error)
-            {
-               normalMatrix .set (Matrix3 .Identity);
+            Matrix3 .prototype .inverse .call (normalMatrix);
 
-               return normalMatrix;
-            }
+            return normalMatrix;
          };
       })(),
-      enable: function (gl)
+      enable: function (gl, program)
       {
          const browser = this .getBrowser ();
 
-         for (const [location, object] of this .textures)
+         gl .useProgram (program);
+
+         for (const location of this .textures)
          {
             const
-               texture     = object .texture,
+               texture     = location .texture,
                textureUnit = browser .getTextureUnit (texture .getTextureType ());
 
             if (textureUnit === undefined)
             {
-               console .warn ("Not enough combined texture units for uniform variable '" + object .name + "' available.");
+               console .warn ("Not enough combined texture units for uniform variable '" + location .name + "' available.");
                return;
             }
 
@@ -1113,161 +1139,140 @@ function (X3DCast,
             gl .uniform1i (location, textureUnit);
          }
       },
-      enableFloatAttrib: function (gl, name, buffer, components)
-      {
-         const location = gl. getAttribLocation (this .getProgram (), name);
-
-         if (location === -1)
-            return;
-
-         gl .enableVertexAttribArray (location);
-
-         gl .bindBuffer (gl .ARRAY_BUFFER, buffer);
-         gl .vertexAttribPointer (location, components, gl .FLOAT, false, 0, 0);
-      },
-      disableFloatAttrib: function (gl, name)
+      enableFloatAttrib: function (gl, name, buffer, components, stride, offset)
       {
          const location = gl .getAttribLocation (this .getProgram (), name);
 
          if (location === -1)
             return;
 
-         gl .disableVertexAttribArray (location);
+         gl .bindBuffer (gl .ARRAY_BUFFER, buffer);
+         gl .enableVertexAttribArray (location);
+         gl .vertexAttribPointer (location, components, gl .FLOAT, false, stride, offset);
       },
-      enableMatrix3Attrib: function (gl, name, buffer)
+      enableMatrix3Attrib: function (gl, name, buffer, stride, offset)
       {
-         const location = gl .getAttribLocation (this .getProgram (), name);
+         const location0 = gl .getAttribLocation (this .getProgram (), name);
 
-         if (location === -1)
+         if (location0 === -1)
             return;
 
-         gl .enableVertexAttribArray (location);
-         gl .enableVertexAttribArray (location + 1);
-         gl .enableVertexAttribArray (location + 2);
+         stride = stride || 36;
 
          gl .bindBuffer (gl .ARRAY_BUFFER, buffer);
 
-         gl .vertexAttribPointer (location,     3, gl .FLOAT, false, 9 * 4, 3 * 4 * 0);
-         gl .vertexAttribPointer (location + 1, 3, gl .FLOAT, false, 9 * 4, 3 * 4 * 1);
-         gl .vertexAttribPointer (location + 2, 3, gl .FLOAT, false, 9 * 4, 3 * 4 * 2);
-      },
-      disableMatrix3Attrib: function (gl, name)
-      {
-         const location = gl .getAttribLocation (this .getProgram (), name);
-
-         if (location === -1)
-            return;
+         for (let i = 0; i < 3; ++ i)
+         {
+            const location = location0 + i;
 
-         gl .disableVertexAttribArray (location);
-         gl .disableVertexAttribArray (location + 1);
-         gl .disableVertexAttribArray (location + 2);
+            gl .enableVertexAttribArray (location);
+            gl .vertexAttribPointer (location, 3, gl .FLOAT, false, stride, offset + 12 * i);
+         }
       },
-      enableMatrix4Attrib: function (gl, name, buffer)
+      enableMatrix4Attrib: function (gl, name, buffer, stride, offset)
       {
-         const location = gl .getAttribLocation (this .getProgram (), name);
+         const location0 = gl .getAttribLocation (this .getProgram (), name);
 
-         if (location === -1)
+         if (location0 === -1)
             return;
 
-         gl .enableVertexAttribArray (location);
-         gl .enableVertexAttribArray (location + 1);
-         gl .enableVertexAttribArray (location + 2);
-         gl .enableVertexAttribArray (location + 3);
+         stride = stride || 64;
 
          gl .bindBuffer (gl .ARRAY_BUFFER, buffer);
 
-         gl .vertexAttribPointer (location,     4, gl .FLOAT, false, 16 * 4, 4 * 4 * 0);
-         gl .vertexAttribPointer (location + 1, 4, gl .FLOAT, false, 16 * 4, 4 * 4 * 1);
-         gl .vertexAttribPointer (location + 2, 4, gl .FLOAT, false, 16 * 4, 4 * 4 * 2);
-         gl .vertexAttribPointer (location + 3, 4, gl .FLOAT, false, 16 * 4, 4 * 4 * 3);
-      },
-      disableMatrix4Attrib: function (gl, name)
-      {
-         const location = gl .getAttribLocation (this .getProgram (), name);
-
-         if (location === -1)
-            return;
+         for (let i = 0; i < 4; ++ i)
+         {
+            const location = location0 + i;
 
-         gl .disableVertexAttribArray (location);
-         gl .disableVertexAttribArray (location + 1);
-         gl .disableVertexAttribArray (location + 2);
-         gl .disableVertexAttribArray (location + 3);
+            gl .enableVertexAttribArray (location);
+            gl .vertexAttribPointer (location, 4, gl .FLOAT, false, stride, offset + 16 * i);
+         }
       },
-      enableFogDepthAttribute: function (gl, fogDepthBuffer)
+      enableFogDepthAttribute: function (gl, buffer, stride, offset)
       {
-         gl .enableVertexAttribArray (this .x3d_FogDepth);
-         gl .bindBuffer (gl .ARRAY_BUFFER, fogDepthBuffer);
-         gl .vertexAttribPointer (this .x3d_FogDepth, 1, gl .FLOAT, false, 0, 0);
+         const location = this .x3d_FogDepth;
+
+         gl .bindBuffer (gl .ARRAY_BUFFER, buffer);
+         gl .enableVertexAttribArray (location);
+         gl .vertexAttribPointer (location, 1, gl .FLOAT, false, stride, offset);
       },
-      disableFogDepthAttribute: function (gl)
+      enableColorAttribute: function (gl, buffer, stride, offset)
       {
-         gl .disableVertexAttribArray (this .x3d_FogDepth);
+         const location = this .x3d_Color;
+
+         gl .bindBuffer (gl .ARRAY_BUFFER, buffer);
+         gl .enableVertexAttribArray (location);
+         gl .vertexAttribPointer (location, 4, gl .FLOAT, false, stride, offset);
       },
-      enableColorAttribute: function (gl, colorBuffer)
+      colorAttributeDivisor: function (gl, divisor)
       {
-         gl .enableVertexAttribArray (this .x3d_Color);
-         gl .bindBuffer (gl .ARRAY_BUFFER, colorBuffer);
-         gl .vertexAttribPointer (this .x3d_Color, 4, gl .FLOAT, false, 0, 0);
+         gl .vertexAttribDivisor (this .x3d_Color, divisor);
       },
-      disableColorAttribute: function (gl)
+      enableTexCoordAttribute: function (gl, buffers, stride, offset)
       {
-         gl .disableVertexAttribArray (this .x3d_Color);
+         for (const [i, location] of this .x3d_TexCoord)
+         {
+            gl .bindBuffer (gl .ARRAY_BUFFER, buffers [i]);
+            gl .enableVertexAttribArray (location);
+            gl .vertexAttribPointer (location, 4, gl .FLOAT, false, stride, offset);
+         }
       },
-      enableTexCoordAttribute: function (gl, texCoordBuffers, d)
+      texCoordAttributeDivisor: function (gl, divisor)
       {
-         const length = Math .min (this .x3d_MaxTextures, texCoordBuffers .length);
-
-         for (let i = 0; i < length; ++ i)
+         for (const [i, location] of this .x3d_TexCoord)
          {
-            const x3d_TexCoord = this .x3d_TexCoord [i];
-
-            if (x3d_TexCoord === -1)
-               continue;
-
-            gl .enableVertexAttribArray (x3d_TexCoord);
-            gl .bindBuffer (gl .ARRAY_BUFFER, texCoordBuffers [i]);
-            gl .vertexAttribPointer (x3d_TexCoord, 4, gl .FLOAT, false, 0, 0);
+            gl .vertexAttribDivisor (location, divisor);
          }
       },
-      disableTexCoordAttribute: function (gl)
+      enableNormalAttribute: function (gl, buffer, stride, offset)
       {
-         for (let i = 0, length = this .x3d_MaxTextures; i < length; ++ i)
-         {
-            const x3d_TexCoord = this .x3d_TexCoord [i];
+         const location = this .x3d_Normal;
 
-            if (x3d_TexCoord === -1)
-               continue;
-
-            gl .disableVertexAttribArray (x3d_TexCoord);
-         }
+         gl .bindBuffer (gl .ARRAY_BUFFER, buffer);
+         gl .enableVertexAttribArray (location);
+         gl .vertexAttribPointer (location, 3, gl .FLOAT, false, stride, offset);
       },
-      enableNormalAttribute: function (gl, normalBuffer)
+      normalAttributeDivisor: function (gl, divisor)
       {
-         gl .enableVertexAttribArray (this .x3d_Normal);
-         gl .bindBuffer (gl .ARRAY_BUFFER, normalBuffer);
-         gl .vertexAttribPointer (this .x3d_Normal, 3, gl .FLOAT, false, 0, 0);
+         gl .vertexAttribDivisor (this .x3d_Normal, divisor);
       },
-      disableNormalAttribute: function (gl)
+      enableVertexAttribute: function (gl, buffer, stride, offset)
       {
-         gl .disableVertexAttribArray (this .x3d_Normal);
+         const location = this .x3d_Vertex;
+
+         gl .bindBuffer (gl .ARRAY_BUFFER, buffer);
+         gl .enableVertexAttribArray (location);
+         gl .vertexAttribPointer (location, 4, gl .FLOAT, false, stride, offset);
       },
-      enableVertexAttribute: function (gl, vertexBuffer)
+      vertexAttributeDivisor: function (gl, divisor)
       {
-         gl .enableVertexAttribArray (this .x3d_Vertex);
-         gl .bindBuffer (gl .ARRAY_BUFFER, vertexBuffer);
-         gl .vertexAttribPointer (this .x3d_Vertex, 4, gl .FLOAT, false, 0, 0);
+         gl .vertexAttribDivisor (this .x3d_Vertex, divisor);
       },
-      disableVertexAttribute: function (gl)
+      enableParticleAttribute: function (gl, buffer, stride, offset, divisor)
       {
-         gl .disableVertexAttribArray (this .x3d_Vertex);
+         const location = this .x3d_Particle;
+
+         gl .bindBuffer (gl .ARRAY_BUFFER, buffer);
+         gl .enableVertexAttribArray (location);
+         gl .vertexAttribPointer (location, 4, gl .FLOAT, false, stride, offset);
+         gl .vertexAttribDivisor (location, divisor);
       },
-      setParticle: function (gl, particle, modelViewMatrix)
+      enableParticleMatrixAttribute: function (gl, buffer, stride, offset, divisor)
       {
-         gl .uniformMatrix4fv (this .x3d_ModelViewMatrix, false, modelViewMatrix);
+         const location0 = this .x3d_ParticleMatrix;
 
-         gl .uniform1i (this .x3d_ParticleId,          particle .id);
-         gl .uniform1i (this .x3d_ParticleLife,        particle .life);
-         gl .uniform1f (this .x3d_ParticleElapsedTime, particle .elapsedTime / particle .lifetime);
+         stride = stride || 64;
+
+         gl .bindBuffer (gl .ARRAY_BUFFER, buffer);
+
+         for (let i = 0; i < 4; ++ i)
+         {
+            const location = location0 + i;
+
+            gl .enableVertexAttribArray (location);
+            gl .vertexAttribPointer (location, 4, gl .FLOAT, false, stride, offset + 16 * i);
+            gl .vertexAttribDivisor (location, divisor);
+         }
       },
       getProgramInfo: function ()
       {
@@ -1284,8 +1289,8 @@ function (X3DCast,
                attributeCount: 0,
                uniformCount: 0,
             },
-            activeUniforms   = gl .getProgramParameter (program, gl.ACTIVE_UNIFORMS),
-            activeAttributes = gl .getProgramParameter (program, gl.ACTIVE_ATTRIBUTES);
+            activeUniforms   = gl .getProgramParameter (program, gl .ACTIVE_UNIFORMS),
+            activeAttributes = gl .getProgramParameter (program, gl .ACTIVE_ATTRIBUTES);
 
          // Taken from the WebGl spec:
          // http://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14
@@ -1350,5 +1355,10 @@ function (X3DCast,
       },
    };
 
+   function lcfirst (string)
+   {
+      return string [0] .toLowerCase () + string .slice (1);
+   }
+
    return X3DProgrammableShaderObject;
 });

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

@@ -91,7 +91,7 @@ function (Fields,
       {
          this ._isValid = this .valid = value;
       },
-      getValid: function ()
+      isValid: function ()
       {
          return this .valid;
       },