x_ite 8.8.3 → 8.8.4

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

@@ -421,112 +421,115 @@ Object .assign (X3DProgrammableShaderObject .prototype,
 
       for (const field of this .getUserDefinedFields ())
       {
+         if (field .getAccessType () === X3DConstants .outputOnly)
+            continue;
+
          const location = gl .getUniformLocation (program, field .getName ());
 
-         if (location)
+         if (!location)
+            continue;
+
+         switch (field .getType ())
          {
-            switch (field .getType ())
+            case X3DConstants .SFImage:
             {
-               case X3DConstants .SFImage:
-               {
-                  location .array = new Int32Array (3 + field .array .length);
-                  break;
-               }
-               case X3DConstants .SFMatrix3d:
-               case X3DConstants .SFMatrix3f:
-               case X3DConstants .SFRotation:
-               {
-                  location .array = new Float32Array (9);
-                  break;
-               }
-               case X3DConstants .SFMatrix4d:
-               case X3DConstants .SFMatrix4f:
-               {
-                  location .array = new Float32Array (16);
-                  break;
-               }
-               case X3DConstants .SFNode:
-               {
-                  break;
-               }
-               case X3DConstants .MFBool:
-               case X3DConstants .MFInt32:
-               {
-                  location .array = new Int32Array (this .getLocationLength (gl, program, field));
-                  break;
-               }
-               case X3DConstants .MFFloat:
-               case X3DConstants .MFDouble:
-               case X3DConstants .MFTime:
-               {
-                  location .array = new Float32Array (this .getLocationLength (gl, program, field));
-                  break;
-               }
-               case X3DConstants .MFImage:
-               {
-                  location .array = new Int32Array (this .getImagesLength (field));
-                  break;
-               }
-               case X3DConstants .MFMatrix3d:
-               case X3DConstants .MFMatrix3f:
-               case X3DConstants .MFRotation:
-               {
-                  location .array = new Float32Array (9 * this .getLocationLength (gl, program, field));
-                  break;
-               }
-               case X3DConstants .MFMatrix4d:
-               case X3DConstants .MFMatrix4f:
-               {
-                  location .array = new Float32Array (16 * this .getLocationLength (gl, program, field));
-                  break;
-               }
-               case X3DConstants .MFNode:
-               {
-                  const locations = location .locations = [ ];
-
-                  for (let i = 0;; ++ i)
-                  {
-                     const l = gl .getUniformLocation (program, field .getName () + "[" + i + "]");
+               location .array = new Int32Array (3 + field .array .length);
+               break;
+            }
+            case X3DConstants .SFMatrix3d:
+            case X3DConstants .SFMatrix3f:
+            case X3DConstants .SFRotation:
+            {
+               location .array = new Float32Array (9);
+               break;
+            }
+            case X3DConstants .SFMatrix4d:
+            case X3DConstants .SFMatrix4f:
+            {
+               location .array = new Float32Array (16);
+               break;
+            }
+            case X3DConstants .SFNode:
+            {
+               break;
+            }
+            case X3DConstants .MFBool:
+            case X3DConstants .MFInt32:
+            {
+               location .array = new Int32Array (this .getLocationLength (gl, program, field));
+               break;
+            }
+            case X3DConstants .MFFloat:
+            case X3DConstants .MFDouble:
+            case X3DConstants .MFTime:
+            {
+               location .array = new Float32Array (this .getLocationLength (gl, program, field));
+               break;
+            }
+            case X3DConstants .MFImage:
+            {
+               location .array = new Int32Array (this .getImagesLength (field));
+               break;
+            }
+            case X3DConstants .MFMatrix3d:
+            case X3DConstants .MFMatrix3f:
+            case X3DConstants .MFRotation:
+            {
+               location .array = new Float32Array (9 * this .getLocationLength (gl, program, field));
+               break;
+            }
+            case X3DConstants .MFMatrix4d:
+            case X3DConstants .MFMatrix4f:
+            {
+               location .array = new Float32Array (16 * this .getLocationLength (gl, program, field));
+               break;
+            }
+            case X3DConstants .MFNode:
+            {
+               const locations = location .locations = [ ];
 
-                     if (! l)
-                        break;
+               for (let i = 0;; ++ i)
+               {
+                  const l = gl .getUniformLocation (program, field .getName () + "[" + i + "]");
 
-                     locations .push (l);
-                  }
+                  if (! l)
+                     break;
 
-                  break;
-               }
-               case X3DConstants .MFVec2d:
-               case X3DConstants .MFVec2f:
-               {
-                  location .array = new Float32Array (2 * this .getLocationLength (gl, program, field));
-                  break;
-               }
-               case X3DConstants .MFVec3d:
-               case X3DConstants .MFVec3f:
-               case X3DConstants .MFColor:
-               {
-                  location .array = new Float32Array (3 * this .getLocationLength (gl, program, field));
-                  break;
-               }
-               case X3DConstants .MFVec4d:
-               case X3DConstants .MFVec4f:
-               case X3DConstants .MFColorRGBA:
-               {
-                  location .array = new Float32Array (4 * this .getLocationLength (gl, program, field));
-                  break;
+                  locations .push (l);
                }
+
+               break;
+            }
+            case X3DConstants .MFVec2d:
+            case X3DConstants .MFVec2f:
+            {
+               location .array = new Float32Array (2 * this .getLocationLength (gl, program, field));
+               break;
             }
+            case X3DConstants .MFVec3d:
+            case X3DConstants .MFVec3f:
+            case X3DConstants .MFColor:
+            {
+               location .array = new Float32Array (3 * this .getLocationLength (gl, program, field));
+               break;
+            }
+            case X3DConstants .MFVec4d:
+            case X3DConstants .MFVec4f:
+            case X3DConstants .MFColorRGBA:
+            {
+               location .array = new Float32Array (4 * this .getLocationLength (gl, program, field));
+               break;
+            }
+         }
 
-            if (location .array)
-               field [_uniformLocation] = location .array .length ? location : null;
-            else
-               field [_uniformLocation] = location;
+         if (location .array)
+            field [_uniformLocation] = location .array .length ? location : null;
+         else
+            field [_uniformLocation] = location;
 
-            field .addInterest ("set_field__", this);
+         field .addInterest ("set_field__", this);
 
-            this .set_field__ (field);
-         }
+         this .set_field__ (field);
       }
    },
    removeShaderFields ()
@@ -534,7 +537,7 @@ Object .assign (X3DProgrammableShaderObject .prototype,
       for (const field of this .getUserDefinedFields ())
          field .removeInterest ("set_field__", this);
    },
-   set_field__: (function ()
+   set_field__: (() =>
    {
       const rotation = new Float32Array (9);
 
@@ -547,361 +550,361 @@ Object .assign (X3DProgrammableShaderObject .prototype,
 
          gl .useProgram (program);
 
-         if (location)
+         if (!location)
+            return;
+
+         switch (field .getType ())
          {
-            switch (field .getType ())
+            case X3DConstants .SFBool:
+            case X3DConstants .SFInt32:
             {
-               case X3DConstants .SFBool:
-               case X3DConstants .SFInt32:
-               {
-                  gl .uniform1i (location, field .getValue ());
-                  return;
-               }
-               case X3DConstants .SFColor:
-               {
-                  const value = field .getValue ();
-                  gl .uniform3f (location, value .r, value .g, value .b);
-                  return;
-               }
-               case X3DConstants .SFColorRGBA:
-               {
-                  const value = field .getValue ();
-                  gl .uniform4f (location, value .r, value .g, value .b, value .a);
-                  return;
-               }
-               case X3DConstants .SFDouble:
-               case X3DConstants .SFFloat:
-               case X3DConstants .SFTime:
-               {
-                  gl .uniform1f (location, field .getValue ());
-                  return;
-               }
-               case X3DConstants .SFImage:
-               {
-                  let array = location .array;
-
-                  const
-                     pixels = field .array,
-                     length = 3 + pixels .length;
-
-                  if (length !== array .length)
-                     array = location .array = new Int32Array (length);
+               gl .uniform1i (location, field .getValue ());
+               return;
+            }
+            case X3DConstants .SFColor:
+            {
+               const value = field .getValue ();
+               gl .uniform3f (location, value .r, value .g, value .b);
+               return;
+            }
+            case X3DConstants .SFColorRGBA:
+            {
+               const value = field .getValue ();
+               gl .uniform4f (location, value .r, value .g, value .b, value .a);
+               return;
+            }
+            case X3DConstants .SFDouble:
+            case X3DConstants .SFFloat:
+            case X3DConstants .SFTime:
+            {
+               gl .uniform1f (location, field .getValue ());
+               return;
+            }
+            case X3DConstants .SFImage:
+            {
+               let array = location .array;
 
-                  array [0] = field .width;
-                  array [1] = field .height;
-                  array [2] = field .comp;
+               const
+                  pixels = field .array,
+                  length = 3 + pixels .length;
 
-                  for (let a = 3, p = 0, pl = pixels .length; p < pl; ++ p, ++ a)
-                     array [a] = pixels [p];
+               if (length !== array .length)
+                  array = location .array = new Int32Array (length);
 
-                  gl .uniform1iv (location, array);
-                  return;
-               }
-               case X3DConstants .SFMatrix3d:
-               case X3DConstants .SFMatrix3f:
-               {
-                  location .array .set (field .getValue ());
+               array [0] = field .width;
+               array [1] = field .height;
+               array [2] = field .comp;
 
-                  gl .uniformMatrix3fv (location, false, location .array);
-                  return;
-               }
-               case X3DConstants .SFMatrix4d:
-               case X3DConstants .SFMatrix4f:
-               {
-                  location .array .set (field .getValue ());
+               for (let a = 3, p = 0, pl = pixels .length; p < pl; ++ p, ++ a)
+                  array [a] = pixels [p];
 
-                  gl .uniformMatrix4fv (location, false, location .array);
-                  return;
-               }
-               case X3DConstants .SFNode:
-               {
-                  const texture = X3DCast (X3DConstants .X3DTextureNode, field);
+               gl .uniform1iv (location, array);
+               return;
+            }
+            case X3DConstants .SFMatrix3d:
+            case X3DConstants .SFMatrix3f:
+            {
+               location .array .set (field .getValue ());
 
-                  if (texture)
-                  {
-                     location .name    = field .getName ();
-                     location .texture = texture;
+               gl .uniformMatrix3fv (location, false, location .array);
+               return;
+            }
+            case X3DConstants .SFMatrix4d:
+            case X3DConstants .SFMatrix4f:
+            {
+               location .array .set (field .getValue ());
 
-                     this .textures .add (location);
-                  }
-                  else
-                  {
-                     this .textures .delete (location);
-                  }
+               gl .uniformMatrix4fv (location, false, location .array);
+               return;
+            }
+            case X3DConstants .SFNode:
+            {
+               const texture = X3DCast (X3DConstants .X3DTextureNode, field);
 
-                  return;
-               }
-               case X3DConstants .SFRotation:
+               if (texture)
                {
-                  field .getValue () .getMatrix (location .array);
+                  location .name    = field .getName ();
+                  location .texture = texture;
 
-                  gl .uniformMatrix3fv (location, false, location .array);
-                  return;
+                  this .textures .add (location);
                }
-               case X3DConstants .SFString:
+               else
                {
-                  return;
+                  this .textures .delete (location);
                }
-               case X3DConstants .SFVec2d:
-               case X3DConstants .SFVec2f:
-               {
-                  const value = field .getValue ();
-                  gl .uniform2f (location, value .x, value .y);
-                  return;
-               }
-               case X3DConstants .SFVec3d:
-               case X3DConstants .SFVec3f:
-               {
-                  const value = field .getValue ();
-                  gl .uniform3f (location, value .x, value .y, value .z);
-                  return;
-               }
-               case X3DConstants .SFVec4d:
-               case X3DConstants .SFVec4f:
-               {
-                  const value = field .getValue ();
-                  gl .uniform4f (location, value .x, value .y, value .z, value .w);
-                  return;
-               }
-               case X3DConstants .MFBool:
-               case X3DConstants .MFInt32:
-               {
-                  const array = location .array;
 
-                  for (var i = 0, length = field .length; i < length; ++ i)
-                     array [i] = field [i];
+               return;
+            }
+            case X3DConstants .SFRotation:
+            {
+               field .getValue () .getMatrix (location .array);
 
-                  for (let length = array .length; i < length; ++ i)
-                     array [i] = 0;
+               gl .uniformMatrix3fv (location, false, location .array);
+               return;
+            }
+            case X3DConstants .SFString:
+            {
+               return;
+            }
+            case X3DConstants .SFVec2d:
+            case X3DConstants .SFVec2f:
+            {
+               const value = field .getValue ();
+               gl .uniform2f (location, value .x, value .y);
+               return;
+            }
+            case X3DConstants .SFVec3d:
+            case X3DConstants .SFVec3f:
+            {
+               const value = field .getValue ();
+               gl .uniform3f (location, value .x, value .y, value .z);
+               return;
+            }
+            case X3DConstants .SFVec4d:
+            case X3DConstants .SFVec4f:
+            {
+               const value = field .getValue ();
+               gl .uniform4f (location, value .x, value .y, value .z, value .w);
+               return;
+            }
+            case X3DConstants .MFBool:
+            case X3DConstants .MFInt32:
+            {
+               const array = location .array;
 
-                  gl .uniform1iv (location, array);
-                  return;
-               }
-               case X3DConstants .MFColor:
-               {
-                  const array = location .array;
+               for (var i = 0, length = field .length; i < length; ++ i)
+                  array [i] = field [i];
 
-                  for (var i = 0, k = 0, length = field .length; i < length; ++ i)
-                  {
-                     const color = field [i];
+               for (let length = array .length; i < length; ++ i)
+                  array [i] = 0;
 
-                     array [k++] = color .r;
-                     array [k++] = color .g;
-                     array [k++] = color .b;
-                  }
+               gl .uniform1iv (location, array);
+               return;
+            }
+            case X3DConstants .MFColor:
+            {
+               const array = location .array;
 
-                  for (let length = array .length; k < length; ++ k)
-                     array [k] = 0;
+               for (var i = 0, k = 0, length = field .length; i < length; ++ i)
+               {
+                  const color = field [i];
 
-                  gl .uniform3fv (location, array);
-                  return;
+                  array [k++] = color .r;
+                  array [k++] = color .g;
+                  array [k++] = color .b;
                }
-               case X3DConstants .MFColorRGBA:
-               {
-                  const array = location .array;
 
-                  for (var i = 0, k = 0, length = field .length; i < length; ++ i)
-                  {
-                     const color = field [i];
+               for (let length = array .length; k < length; ++ k)
+                  array [k] = 0;
 
-                     array [k++] = color .r;
-                     array [k++] = color .g;
-                     array [k++] = color .b;
-                     array [k++] = color .a;
-                  }
+               gl .uniform3fv (location, array);
+               return;
+            }
+            case X3DConstants .MFColorRGBA:
+            {
+               const array = location .array;
 
-                  for (let length = array .length; k < length; ++ k)
-                     array [k] = 0;
+               for (var i = 0, k = 0, length = field .length; i < length; ++ i)
+               {
+                  const color = field [i];
 
-                  gl .uniform4fv (location, array);
-                  return;
+                  array [k++] = color .r;
+                  array [k++] = color .g;
+                  array [k++] = color .b;
+                  array [k++] = color .a;
                }
-               case X3DConstants .MFDouble:
-               case X3DConstants .MFFloat:
-               case X3DConstants .MFTime:
-               {
-                  const array = location .array;
 
-                  for (var i = 0, length = field .length; i < length; ++ i)
-                     array [i] = field [i];
+               for (let length = array .length; k < length; ++ k)
+                  array [k] = 0;
 
-                  for (let length = array .length; i < length; ++ i)
-                     array [i] = 0;
+               gl .uniform4fv (location, array);
+               return;
+            }
+            case X3DConstants .MFDouble:
+            case X3DConstants .MFFloat:
+            case X3DConstants .MFTime:
+            {
+               const array = location .array;
 
-                  gl .uniform1fv (location, array);
-                  return;
-               }
-               case X3DConstants .MFImage:
-               {
-                  const array = location .array;
+               for (var i = 0, length = field .length; i < length; ++ i)
+                  array [i] = field [i];
 
-                  for (let i = 0, a = 0, length = field .length; i < length; ++ i)
-                  {
-                     const
-                        value  = field [i],
-                        pixels = value .array;
+               for (let length = array .length; i < length; ++ i)
+                  array [i] = 0;
+
+               gl .uniform1fv (location, array);
+               return;
+            }
+            case X3DConstants .MFImage:
+            {
+               const array = location .array;
 
-                     array [a ++] = value .width;
-                     array [a ++] = value .height;
-                     array [a ++] = value .comp;
+               for (let i = 0, a = 0, length = field .length; i < length; ++ i)
+               {
+                  const
+                     value  = field [i],
+                     pixels = value .array;
 
-                     for (let p = 0, pl = pixels .length; p < pl; ++ p)
-                        array [a ++] = pixels [p];
-                  }
+                  array [a ++] = value .width;
+                  array [a ++] = value .height;
+                  array [a ++] = value .comp;
 
-                  gl .uniform1iv (location, array);
-                  return;
+                  for (let p = 0, pl = pixels .length; p < pl; ++ p)
+                     array [a ++] = pixels [p];
                }
-               case X3DConstants .MFMatrix3d:
-               case X3DConstants .MFMatrix3f:
+
+               gl .uniform1iv (location, array);
+               return;
+            }
+            case X3DConstants .MFMatrix3d:
+            case X3DConstants .MFMatrix3f:
+            {
+               const array = location .array;
+
+               for (var i = 0, k = 0, length = field .length; i < length; ++ i)
                {
-                  const array = location .array;
+                  const matrix = field [i];
 
-                  for (var i = 0, k = 0, length = field .length; i < length; ++ i)
-                  {
-                     const matrix = field [i];
+                  for (let m = 0; m < 9; ++ m)
+                     array [k++] = matrix [m];
+               }
 
-                     for (let m = 0; m < 9; ++ m)
-                        array [k++] = matrix [m];
-                  }
+               for (let length = array .length; k < length; ++ k)
+                  array [k] = 0;
 
-                  for (let length = array .length; k < length; ++ k)
-                     array [k] = 0;
+               gl .uniformMatrix3fv (location, false, array);
+               return;
+            }
+            case X3DConstants .MFMatrix4d:
+            case X3DConstants .MFMatrix4f:
+            {
+               const array = location .array;
 
-                  gl .uniformMatrix3fv (location, false, array);
-                  return;
-               }
-               case X3DConstants .MFMatrix4d:
-               case X3DConstants .MFMatrix4f:
+               for (var i = 0, k = 0, length = field .length; i < length; ++ i)
                {
-                  const array = location .array;
+                  const matrix = field [i];
 
-                  for (var i = 0, k = 0, length = field .length; i < length; ++ i)
-                  {
-                     const matrix = field [i];
+                  for (let m = 0; m < 16; ++ m)
+                     array [k++] = matrix [m];
+               }
 
-                     for (let m = 0; m < 16; ++ m)
-                        array [k++] = matrix [m];
-                  }
+               for (let length = array .length; k < length; ++ k)
+                  array [k] = 0;
 
-                  for (let length = array .length; k < length; ++ k)
-                     array [k] = 0;
+               gl .uniformMatrix4fv (location, false, array);
+               return;
+            }
+            case X3DConstants .MFNode:
+            {
+               const locations = location .locations;
 
-                  gl .uniformMatrix4fv (location, false, array);
-                  return;
-               }
-               case X3DConstants .MFNode:
+               for (let i = 0, length = field .length; i < length; ++ i)
                {
-                  const locations = location .locations;
+                  const texture = X3DCast (X3DConstants .X3DTextureNode, field [i]);
 
-                  for (let i = 0, length = field .length; i < length; ++ i)
+                  if (texture)
                   {
-                     const texture = X3DCast (X3DConstants .X3DTextureNode, field [i]);
-
-                     if (texture)
-                     {
-                        locations [i] .name    = field .getName ();
-                        locations [i] .texture = texture;
-
-                        this .textures .add (locations [i]);
-                     }
-                     else
-                     {
-                        this .textures .delete (locations [i]);
-                     }
-                  }
-
-                  return;
-               }
-               case X3DConstants .MFRotation:
-               {
-                  const array = location .array;
+                     locations [i] .name    = field .getName ();
+                     locations [i] .texture = texture;
 
-                  for (var i = 0, k = 0, length = field .length; i < length; ++ i)
+                     this .textures .add (locations [i]);
+                  }
+                  else
                   {
-                     field [i] .getValue () .getMatrix (rotation);
-
-                     array [k++] = rotation [0];
-                     array [k++] = rotation [1];
-                     array [k++] = rotation [2];
-                     array [k++] = rotation [3];
-                     array [k++] = rotation [4];
-                     array [k++] = rotation [5];
-                     array [k++] = rotation [6];
-                     array [k++] = rotation [7];
-                     array [k++] = rotation [8];
+                     this .textures .delete (locations [i]);
                   }
+               }
 
-                  for (let length = array .length; k < length; ++ k)
-                     array [k] = 0;
+               return;
+            }
+            case X3DConstants .MFRotation:
+            {
+               const array = location .array;
 
-                  gl .uniformMatrix3fv (location, false, array);
-                  return;
-               }
-               case X3DConstants .MFString:
+               for (var i = 0, k = 0, length = field .length; i < length; ++ i)
                {
-                  return;
+                  field [i] .getValue () .getMatrix (rotation);
+
+                  array [k++] = rotation [0];
+                  array [k++] = rotation [1];
+                  array [k++] = rotation [2];
+                  array [k++] = rotation [3];
+                  array [k++] = rotation [4];
+                  array [k++] = rotation [5];
+                  array [k++] = rotation [6];
+                  array [k++] = rotation [7];
+                  array [k++] = rotation [8];
                }
-               case X3DConstants .MFVec2d:
-               case X3DConstants .MFVec2f:
-               {
-                  const array = location .array;
 
-                  for (var i = 0, k = 0, length = field .length; i < length; ++ i)
-                  {
-                     const vector = field [i];
+               for (let length = array .length; k < length; ++ k)
+                  array [k] = 0;
 
-                     array [k++] = vector .x;
-                     array [k++] = vector .y;
-                  }
+               gl .uniformMatrix3fv (location, false, array);
+               return;
+            }
+            case X3DConstants .MFString:
+            {
+               return;
+            }
+            case X3DConstants .MFVec2d:
+            case X3DConstants .MFVec2f:
+            {
+               const array = location .array;
 
-                  for (let length = array .length; k < length; ++ k)
-                     array [k] = 0;
+               for (var i = 0, k = 0, length = field .length; i < length; ++ i)
+               {
+                  const vector = field [i];
 
-                  gl .uniform2fv (location, array);
-                  return;
+                  array [k++] = vector .x;
+                  array [k++] = vector .y;
                }
-               case X3DConstants .MFVec3d:
-               case X3DConstants .MFVec3f:
-               {
-                  const array = location .array;
 
-                  for (var i = 0, k = 0, length = field .length; i < length; ++ i)
-                  {
-                     const vector = field [i];
+               for (let length = array .length; k < length; ++ k)
+                  array [k] = 0;
 
-                     array [k++] = vector .x;
-                     array [k++] = vector .y;
-                     array [k++] = vector .z;
-                  }
+               gl .uniform2fv (location, array);
+               return;
+            }
+            case X3DConstants .MFVec3d:
+            case X3DConstants .MFVec3f:
+            {
+               const array = location .array;
 
-                  for (let length = array .length; k < length; ++ k)
-                     array [k] = 0;
+               for (var i = 0, k = 0, length = field .length; i < length; ++ i)
+               {
+                  const vector = field [i];
 
-                  gl .uniform3fv (location, array);
-                  return;
+                  array [k++] = vector .x;
+                  array [k++] = vector .y;
+                  array [k++] = vector .z;
                }
-               case X3DConstants .MFVec4d:
-               case X3DConstants .MFVec4f:
-               {
-                  const array = location .array;
 
-                  for (var i = 0, k = 0, length = field .length; i < length; ++ i)
-                  {
-                     const vector = field [i];
+               for (let length = array .length; k < length; ++ k)
+                  array [k] = 0;
 
-                     array [k++] = vector .x;
-                     array [k++] = vector .y;
-                     array [k++] = vector .z;
-                     array [k++] = vector .w;
-                  }
+               gl .uniform3fv (location, array);
+               return;
+            }
+            case X3DConstants .MFVec4d:
+            case X3DConstants .MFVec4f:
+            {
+               const array = location .array;
 
-                  for (let length = array .length; k < length; ++ k)
-                     array [k] = 0;
+               for (var i = 0, k = 0, length = field .length; i < length; ++ i)
+               {
+                  const vector = field [i];
 
-                  gl .uniform4fv (location, array);
-                  return;
+                  array [k++] = vector .x;
+                  array [k++] = vector .y;
+                  array [k++] = vector .z;
+                  array [k++] = vector .w;
                }
+
+               for (let length = array .length; k < length; ++ k)
+                  array [k] = 0;
+
+               gl .uniform4fv (location, array);
+               return;
             }
          }
       };
@@ -963,7 +966,7 @@ Object .assign (X3DProgrammableShaderObject .prototype,
       for (const clipPlane of clipPlanes)
          clipPlane .setShaderUniforms (gl, this);
    },
-   setUniforms: (function ()
+   setUniforms: (() =>
    {
       const normalMatrix = new Float32Array (9);
 
@@ -1301,8 +1304,8 @@ Object .assign (X3DProgrammableShaderObject .prototype,
          result .attributeCount += attribute .size;
       }
 
-      result .uniforms   .sort (function (a, b) { return cmp (a .name, b .name); });
-      result .attributes .sort (function (a, b) { return cmp (a .name, b .name); });
+      result .uniforms   .sort ((a, b) => cmp (a .name, b .name));
+      result .attributes .sort ((a, b) => cmp (a .name, b .name));
 
       return result;
    },