x_ite 8.6.8 → 8.6.9

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

@@ -110,9 +110,6 @@ X3DProgrammableShaderObject .prototype =
 
       browser .getRenderingProperties () ._LogarithmicDepthBuffer .addInterest ("set_logarithmicDepthBuffer__", this);
 
-      // Use by multi texture nodes.
-      this .x3d_MaxTextures = browser .getMaxTextures ();
-
       this .set_logarithmicDepthBuffer__ ();
    },
    set_logarithmicDepthBuffer__: function ()
@@ -136,12 +133,14 @@ X3DProgrammableShaderObject .prototype =
       // Get uniforms and attributes.
 
       const
-         program       = this .getProgram (),
-         browser       = this .getBrowser (),
-         gl            = browser .getContext (),
-         maxClipPlanes = browser .getMaxClipPlanes (),
-         maxLights     = browser .getMaxLights (),
-         maxTextures   = browser .getMaxTextures ();
+         program              = this .getProgram (),
+         browser              = this .getBrowser (),
+         gl                   = browser .getContext (),
+         maxClipPlanes        = browser .getMaxClipPlanes (),
+         maxLights            = browser .getMaxLights (),
+         maxTextures          = browser .getMaxTextures (),
+         maxTextureTransforms = browser .getMaxTextureTransforms (),
+         maxTexCoords         = browser .getMaxTexCoords ();
 
       gl .useProgram (program);
 
@@ -242,17 +241,6 @@ X3DProgrammableShaderObject .prototype =
 
       for (let i = 0; i < maxTextures; ++ i)
       {
-         // Attributes
-
-         const x3d_TexCoord = this .getAttribLocation (gl, program, "x3d_TexCoord" + i, i ? "" : "x3d_TexCoord");
-
-         if (x3d_TexCoord !== -1)
-            this .x3d_TexCoord .push ([i, x3d_TexCoord]);
-
-         // Uniforms
-
-         this .x3d_TextureMatrix [i] = gl .getUniformLocation (program, "x3d_TextureMatrix[" + i + "]");
-
          this .x3d_TextureCoordinateGeneratorMode [i]      = gl .getUniformLocation (program, "x3d_TextureCoordinateGenerator[" + i + "].mode");
          this .x3d_TextureCoordinateGeneratorParameter [i] = gl .getUniformLocation (program, "x3d_TextureCoordinateGenerator[" + i + "].parameter");
 
@@ -272,6 +260,22 @@ X3DProgrammableShaderObject .prototype =
          this .x3d_ProjectiveTextureLocation [i] = gl .getUniformLocation (program, "x3d_ProjectiveTextureLocation[" + i + "]");
       }
 
+      for (let i = 0; i < maxTextureTransforms; ++ i)
+      {
+         const uniform = gl .getUniformLocation (program, "x3d_TextureMatrix[" + i + "]");
+
+         if (uniform !== null)
+            this .x3d_TextureMatrix [i] = uniform;
+      }
+
+      for (let i = 0; i < maxTexCoords; ++ i)
+      {
+         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");
@@ -355,7 +359,7 @@ X3DProgrammableShaderObject .prototype =
       for (const uniform of this .x3d_ProjectiveTexture)
          gl .uniform1i (uniform, browser .getDefaultTexture2DUnit ());
 
-      gl .uniform1i  (this .x3d_TexCoordRamp, browser .getDefaultTexture2DUnit ());
+      gl .uniform1i (this .x3d_TexCoordRamp, browser .getDefaultTexture2DUnit ());
    },
    getUniformLocation: function (gl, program, name, depreciated)
    {
@@ -1041,8 +1045,7 @@ X3DProgrammableShaderObject .prototype =
 
          // Fog
 
-         if (fogNode)
-            fogNode .setShaderUniforms (gl, this);
+         fogNode?.setShaderUniforms (gl, this);
 
          // Clip planes and local lights
 
@@ -1059,8 +1062,7 @@ X3DProgrammableShaderObject .prototype =
 
          // Style Properties
 
-         if (stylePropertiesNode)
-            stylePropertiesNode .setShaderUniforms (gl, this);
+         stylePropertiesNode?.setShaderUniforms (gl, this);
 
          // Material
 
@@ -1068,8 +1070,7 @@ X3DProgrammableShaderObject .prototype =
 
          // Texture
 
-         if (textureNode)
-            textureNode .setShaderUniforms (gl, this, renderObject);
+         textureNode?.setShaderUniforms (gl, this, renderObject);
 
          appearanceNode  .getTextureTransform ()  .setShaderUniforms (gl, this);
          geometryContext .getTextureCoordinate () .setShaderUniforms (gl, this);

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

@@ -214,6 +214,10 @@ Material .prototype = Object .assign (Object .create (X3DOneSidedMaterialNode .p
       this .setTransparent (!!(this .getTransparency () ||
                               (this .diffuseTextureNode && this .diffuseTextureNode .isTransparent ())));
    },
+   getBaseTexture: function ()
+   {
+      return this .diffuseTexture;
+   },
    getTextureIndices: (function ()
    {
       let i = 0;

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

@@ -173,6 +173,10 @@ PhysicalMaterial .prototype = Object .assign (Object .create (X3DOneSidedMateria
       this .setTransparent (!!(this .getTransparency () ||
                               (this .baseTextureNode && this .baseTextureNode .isTransparent ())));
    },
+   getBaseTexture: function ()
+   {
+      return this .baseTextureNode;
+   },
    getTextureIndices: (function ()
    {
       let i = 0;

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

@@ -248,6 +248,7 @@ TwoSidedMaterial .prototype = Object .assign (Object .create (X3DMaterialNode .p
    {
       this .setTransparent (Boolean (this ._transparency .getValue () || (this ._separateBackColor .getValue () && this ._backTransparency .getValue ())));
    },
+   getBaseTexture: Material .prototype .getBaseTexture,
    getMaterialKey: Material .prototype .getMaterialKey,
    createShader: Material .prototype .createShader,
    setShaderUniforms: function (gl, shaderObject, renderObject, textureTransformMapping, textureCoordinateMapping, front)

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

@@ -88,6 +88,10 @@ X3DMaterialNode .prototype = Object .assign (Object .create (X3DAppearanceChildN
    {
       return this ._transparent .getValue ();
    },
+   getBaseTexture: function ()
+   {
+      return null;
+   },
    setTexture: function (index, textureNode)
    {
       const textureType = textureNode ? textureNode .getTextureType () - 1 : 0;
@@ -212,37 +216,35 @@ X3DMaterialNode .prototype = Object .assign (Object .create (X3DAppearanceChildN
             options .push ("X3D_STYLE_PROPERTIES");
 
          if (+this .textureBits)
-         {
             options .push ("X3D_MATERIAL_TEXTURES");
-            options .push ("X3D_NUM_TEXTURE_TRANSFORMS " + (appearanceNode .getTextureTransformMapping () .size || 1));
-            options .push ("X3D_NUM_TEXTURE_COORDINATES " + (geometryContext .getTextureCoordinateMapping () .size || 1));
+
+         if (renderContext .textureNode)
+         {
+            // ScreenText
+
+            options .push ("X3D_TEXTURE",
+                           "X3D_NUM_TEXTURES 1",
+                           "X3D_NUM_TEXTURE_TRANSFORMS 1",
+                           "X3D_NUM_TEXTURE_COORDINATES 1",
+                           "X3D_TEXTURE0_2D");
          }
          else
          {
-            if (renderContext .textureNode)
-            {
-               // ScreenText
-
-               options .push ("X3D_TEXTURE",
-                              "X3D_NUM_TEXTURES 1",
-                              "X3D_NUM_TEXTURE_TRANSFORMS 1",
-                              "X3D_NUM_TEXTURE_COORDINATES 1",
-                              "X3D_TEXTURE0_2D");
-            }
-            else if (+appearanceNode .getTextureBits ())
+            if (+appearanceNode .getTextureBits () && !this .getBaseTexture ())
             {
                const textureNode = appearanceNode .getTexture ();
 
                options .push ("X3D_TEXTURE");
-               options .push ("X3D_NUM_TEXTURES "            + textureNode .getCount ());
-               options .push ("X3D_NUM_TEXTURE_TRANSFORMS "  + textureNode .getCount ());
-               options .push ("X3D_NUM_TEXTURE_COORDINATES " + textureNode .getCount ());
-
-               textureNode .getShaderOptions (options);
+               options .push ("X3D_NUM_TEXTURES " + textureNode .getCount ());
 
                if (textureNode .getType () .includes (X3DConstants .MultiTexture))
                   options .push ("X3D_MULTI_TEXTURING");
+
+               textureNode .getShaderOptions (options);
             }
+
+            options .push ("X3D_NUM_TEXTURE_TRANSFORMS " + (appearanceNode .getTextureTransformMapping () .size || 1));
+            options .push ("X3D_NUM_TEXTURE_COORDINATES " + (geometryContext .textureCoordinateMapping .size || 1));
          }
 
          switch (shapeNode .getShapeKey ())

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

@@ -115,6 +115,10 @@ X3DOneSidedMaterialNode .prototype = Object .assign (Object .create (X3DMaterial
    {
       this .setTransparent (Boolean (this .transparency));
    },
+   getBaseTexture: function ()
+   {
+      return this .getEmissiveTexture ();
+   },
    getEmissiveTexture: function ()
    {
       return this .emissiveTextureNode;

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

@@ -62,7 +62,6 @@ function ImageTexture (executionContext)
    this .addType (X3DConstants .ImageTexture);
 
    this .image    = $("<img></img>");
-   this .canvas   = $("<canvas></canvas>");
    this .urlStack = new Fields .MFString ();
 }
 
@@ -148,7 +147,7 @@ ImageTexture .prototype = Object .assign (Object .create (X3DTexture2DNode .prot
 
       this .loadNext ();
    },
-   setImage: function ()
+   setImage: async function ()
    {
       if (DEBUG)
       {
@@ -159,45 +158,21 @@ ImageTexture .prototype = Object .assign (Object .create (X3DTexture2DNode .prot
       try
       {
          const
-            gl     = this .getBrowser () .getContext (),
-            image  = this .image [0],
-            canvas = this .canvas [0],
-            cx     = canvas .getContext ("2d", { willReadFrequently: true });
-
-         let
-            width  = image .width,
-            height = image .height;
+            gl    = this .getBrowser () .getContext (),
+            image = this .image [0];
 
          // https://developer.mozilla.org/en-US/docs/Web/API/createImageBitmap
          // createImageBitmap
 
-         // Scale image if needed and flip vertically.
-
-         if (gl .getVersion () >= 2 || (Algorithm .isPowerOfTwo (width) && Algorithm .isPowerOfTwo (height)))
+         if (gl .getVersion () === 1 && !(Algorithm .isPowerOfTwo (image .width) && Algorithm .isPowerOfTwo (image .height)))
          {
-            // Flip Y
+            const
+               canvas = document .createElement ("canvas"),
+               cx     = canvas .getContext ("2d", { willReadFrequently: true }),
+               width  = Algorithm .nextPowerOfTwo (image .width),
+               height = Algorithm .nextPowerOfTwo (image .height);
 
-            canvas .width  = width;
-            canvas .height = height;
-
-            cx .clearRect (0, 0, width, height);
-            cx .save ();
-
-            if (!this ._flipVertically .getValue ())
-            {
-               cx .translate (0, height);
-               cx .scale (1, -1);
-            }
-
-            cx .drawImage (image, 0, 0);
-            cx .restore ();
-         }
-         else
-         {
-            // Flip Y and scale image to next power of two.
-
-            width  = Algorithm .nextPowerOfTwo (width);
-            height = Algorithm .nextPowerOfTwo (height);
+            // Flip Y and scale image to next power of two if needed.
 
             canvas .width  = width;
             canvas .height = height;
@@ -213,25 +188,31 @@ ImageTexture .prototype = Object .assign (Object .create (X3DTexture2DNode .prot
 
             cx .drawImage (image, 0, 0, image .width, image .height, 0, 0, width, height);
             cx .restore ();
-         }
 
-         // Determine image alpha.
+            // Determine image alpha.
 
-         const data = cx .getImageData (0, 0, width, height) .data;
+            const
+               data        = cx .getImageData (0, 0, width, height, { premultipliedAlpha: false }) .data,
+               transparent = this .isImageTransparent (data);
 
-         let transparent = false;
+            // Upload image to GPU.
 
-         for (let i = 3, length = data .length; i < length; i += 4)
-         {
-            if (data [i] !== 255)
-            {
-               transparent = true;
-               break;
-            }
+            this .setTexture (width, height, transparent, data, false);
+            this .setLoadState (X3DConstants .COMPLETE_STATE);
          }
+         else
+         {
+            const
+               data        = await this .getImageData (image),
+               transparent = this .isImageTransparent (data),
+               width       = image .width,
+               height      = image .height;
+
+            // Upload image to GPU.
 
-         this .setTexture (width, height, transparent, data, false);
-         this .setLoadState (X3DConstants .COMPLETE_STATE);
+            this .setTexture (width, height, transparent, data, !this ._flipVertically .getValue ());
+            this .setLoadState (X3DConstants .COMPLETE_STATE);
+         }
       }
       catch (error)
       {
@@ -239,6 +220,54 @@ ImageTexture .prototype = Object .assign (Object .create (X3DTexture2DNode .prot
          this .setError ({ type: error .message });
       }
    },
+   getImageData: async function (image)
+   {
+      const
+         gl          = this .getBrowser () .getContext (),
+         framebuffer = gl .createFramebuffer (),
+         texture     = gl .createTexture (),
+         data        = new Uint8Array (image .width * image .height * 4);
+
+      gl .bindFramebuffer (gl.FRAMEBUFFER, framebuffer);
+      gl .bindTexture (gl.TEXTURE_2D, texture);
+      gl .framebufferTexture2D (gl.FRAMEBUFFER, gl .COLOR_ATTACHMENT0, gl .TEXTURE_2D, texture, 0);
+      gl .texImage2D (gl .TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, image);
+      await gl .readPixelsAsync (0, 0, image .width, image .height, gl.RGBA, gl.UNSIGNED_BYTE, data);
+      gl .deleteFramebuffer (framebuffer);
+      gl .deleteTexture (texture);
+
+      return data;
+   },
+   isImageTransparent: function (data)
+   {
+      for (let i = 3, length = data .length; i < length; i += 4)
+      {
+         if (data [i] !== 255)
+            return true;
+      }
+
+      return false;
+   },
+   flipImage (data, width, height, components)
+   {
+      const
+         height1_2   = height >> 1,
+         bytesPerRow = width * components,
+         tmp         = new Uint8Array (bytesPerRow);
+
+      for (let y = 0; y < height1_2; ++ y)
+      {
+         const
+            top    = y * bytesPerRow,
+            bottom = (height - y - 1) * bytesPerRow;
+
+         tmp .set (data .subarray (top, top + bytesPerRow));
+         data .copyWithin (top, bottom, bottom + bytesPerRow);
+         data .set (tmp, bottom);
+      }
+
+      return data;
+   },
    dispose: function ()
    {
       X3DUrlObject     .prototype .dispose .call (this);

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

@@ -63,6 +63,9 @@ function MultiTexture (executionContext)
 
    this .addChildObjects ("loadState", new Fields .SFInt32 (X3DConstants .NOT_STARTED_STATE));
 
+   const browser = this .getBrowser ();
+
+   this .maxTextures  = browser .getMaxTextures ()
    this .color        = new Float32Array (4);
    this .modes        = [ ];
    this .alphaModes   = [ ];
@@ -118,7 +121,7 @@ MultiTexture .prototype = Object .assign (Object .create (X3DTextureNode .protot
    },
    getCount: function ()
    {
-      return Math .min (this .getBrowser () .getMaxTextures (), this .textureNodes .length);
+      return Math .min (this .maxTextures, this .textureNodes .length);
    },
    getMode: function (index)
    {
@@ -281,7 +284,7 @@ MultiTexture .prototype = Object .assign (Object .create (X3DTextureNode .protot
    updateTextureBits: function (textureBits)
    {
       const
-         maxTextures  = this .getBrowser () .getMaxTextures (),
+         maxTextures  = this .maxTextures,
          textureNodes = this .textureNodes,
          channels     = Math .min (maxTextures, textureNodes .length);
 
@@ -294,7 +297,7 @@ MultiTexture .prototype = Object .assign (Object .create (X3DTextureNode .protot
    {
       const
          textureNodes = this .textureNodes,
-         channels     = Math .min (this .getBrowser () .getMaxTextures (), textureNodes .length);
+         channels     = Math .min (this .maxTextures, textureNodes .length);
 
       for (let i = 0; i < channels; ++ i)
          textureNodes [i] .getShaderOptions (options, i);
@@ -308,7 +311,7 @@ MultiTexture .prototype = Object .assign (Object .create (X3DTextureNode .protot
    {
       const
          textureNodes = this .textureNodes,
-         channels     = Math .min (this .getBrowser () .getMaxTextures (), textureNodes .length);
+         channels     = Math .min (this .maxTextures, textureNodes .length);
 
       gl .uniform4fv (shaderObject .x3d_MultiTextureColor, this .color);
 

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

@@ -58,6 +58,9 @@ function MultiTextureCoordinate (executionContext)
 
    this .addType (X3DConstants .MultiTextureCoordinate);
 
+   const browser = this .getBrowser ();
+
+   this .maxTexCoords           = browser .getMaxTexCoords ();
    this .textureCoordinateNodes = [ ];
 }
 
@@ -110,7 +113,7 @@ MultiTextureCoordinate .prototype = Object .assign (Object .create (X3DTextureCo
    },
    getCount: function ()
    {
-      return Math .min (this .getBrowser () .getMaxTextures (), this .textureCoordinateNodes .length);
+      return Math .min (this .maxTexCoords, this .textureCoordinateNodes .length);
    },
    isEmpty: function ()
    {
@@ -136,21 +139,27 @@ MultiTextureCoordinate .prototype = Object .assign (Object .create (X3DTextureCo
    },
    init: function (multiArray)
    {
-      for (const textureCoordinateNode of this .textureCoordinateNodes)
-         textureCoordinateNode .init (multiArray);
+      const
+         textureCoordinateNodes = this .textureCoordinateNodes,
+         length                 = Math .min (this .maxTexCoords, textureCoordinateNodes .length);
+
+      for (let i = 0; i < length; ++ i)
+         textureCoordinateNodes [i] .init (multiArray);
    },
    addPoint: function (index, multiArray)
    {
-      const textureCoordinateNodes = this .textureCoordinateNodes;
+      const
+         textureCoordinateNodes = this .textureCoordinateNodes,
+         length                 = Math .min (this .maxTexCoords, textureCoordinateNodes .length);
 
-      for (let i = 0, length = textureCoordinateNodes .length; i < length; ++ i)
+      for (let i = 0; i < length; ++ i)
          textureCoordinateNodes [i] .addPointToChannel (index, multiArray [i]);
    },
    getTextureCoordinateMapping: function (textureCoordinateMapping)
    {
       const
          textureCoordinateNodes = this .textureCoordinateNodes,
-         length                 = Math .min (this .getBrowser () .getMaxTextures (), textureCoordinateNodes .length);
+         length                 = Math .min (this .maxTexCoords, textureCoordinateNodes .length);
 
       for (let i = 0; i < length; ++ i)
          textureCoordinateNodes [i] .getTextureCoordinateMapping (textureCoordinateMapping, i);
@@ -159,22 +168,16 @@ MultiTextureCoordinate .prototype = Object .assign (Object .create (X3DTextureCo
    {
       const
          textureCoordinateNodes = this .textureCoordinateNodes,
-         length                 = Math .min (shaderObject .x3d_MaxTextures, textureCoordinateNodes .length);
-
-      for (let i = 0; i < length; ++ i)
-         textureCoordinateNodes [i] .setShaderUniformsToChannel (gl, shaderObject, i);
+         length                 = Math .min (this .maxTexCoords, textureCoordinateNodes .length);
 
       if (length)
       {
-         const last = textureCoordinateNodes .at (-1);
-
-         for (let i = length, l = shaderObject .x3d_MaxTextures; i < l; ++ i)
-            last .setShaderUniformsToChannel (gl, shaderObject, i);
+         for (let i = 0; i < length; ++ i)
+            textureCoordinateNodes [i] .setShaderUniforms (gl, shaderObject, i);
       }
       else
       {
-         for (let i = length, l = shaderObject .x3d_MaxTextures; i < l; ++ i)
-            gl .uniform1i (shaderObject .x3d_TextureCoordinateGeneratorMode [i], 0);
+         this .getBrowser () .getDefaultTextureCoordinate () .setShaderUniforms (gl, shaderObject, 0);
       }
    },
 });

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

@@ -51,7 +51,6 @@ import FieldDefinitionArray    from "../../Base/FieldDefinitionArray.js";
 import X3DTextureTransformNode from "./X3DTextureTransformNode.js";
 import X3DConstants            from "../../Base/X3DConstants.js";
 import X3DCast                 from "../../Base/X3DCast.js";
-import Matrix4                 from "../../../standard/Math/Numbers/Matrix4.js";
 
 function MultiTextureTransform (executionContext)
 {
@@ -59,6 +58,9 @@ function MultiTextureTransform (executionContext)
 
    this .addType (X3DConstants .MultiTextureTransform);
 
+   const browser = this .getBrowser ();
+
+   this .maxTextureTransforms  = browser .getMaxTextureTransforms ();
    this .textureTransformNodes = [ ];
 }
 
@@ -102,53 +104,35 @@ MultiTextureTransform .prototype = Object .assign (Object .create (X3DTextureTra
          if (textureTransformNode)
             textureTransformNodes .push (textureTransformNode);
       }
+
+      if (!textureTransformNodes .length)
+         textureTransformNodes .push (this .getBrowser () .getDefaultTextureTransform ());
    },
    getCount: function ()
    {
-      return Math .min (this .getBrowser () .getMaxTextures (), this .textureTransformNodes .length);
+      return Math .min (this .maxTextureTransforms, this .textureTransformNodes .length);
    },
    getTextureTransformMapping: function (textureTransformMapping)
    {
       const
          textureTransformNodes = this .textureTransformNodes,
-         length                = Math .min (this .getBrowser () .getMaxTextures (), textureTransformNodes .length);
+         length                = Math .min (this .maxTextureTransforms, textureTransformNodes .length);
 
       for (let i = 0; i < length; ++ i)
          textureTransformNodes [i] .getTextureTransformMapping (textureTransformMapping, i);
    },
-   setShaderUniforms: (function ()
+   setShaderUniforms: function (gl, shaderObject)
    {
-      const matrixArray = new Float32Array (Matrix4 .Identity);
-
-      return function (gl, shaderObject)
-      {
-         const
-            textureTransformNodes = this .textureTransformNodes,
-            length                = Math .min (shaderObject .x3d_MaxTextures, textureTransformNodes .length);
-
-         for (let i = 0; i < length; ++ i)
-            textureTransformNodes [i] .setShaderUniformsToChannel (gl, shaderObject, i);
-
-         if (length)
-         {
-            const last = textureTransformNodes .at (-1);
+      const
+         textureTransformNodes = this .textureTransformNodes,
+         length                = Math .min (this .maxTextureTransforms, textureTransformNodes .length);
 
-            for (let i = length, l = shaderObject .x3d_MaxTextures; i < l; ++ i)
-               last .setShaderUniformsToChannel (gl, shaderObject, i);
-         }
-         else
-         {
-            for (let i = length, l = shaderObject .x3d_MaxTextures; i < l; ++ i)
-               gl .uniformMatrix4fv (shaderObject .x3d_TextureMatrix [i], false, matrixArray);
-         }
-      };
-   })(),
+      for (let i = 0; i < length; ++ i)
+         textureTransformNodes [i] .setShaderUniforms (gl, shaderObject, i);
+   },
    transformPoint: function (texCoord)
    {
-      if (this .textureTransformNodes .length)
-         return this .textureTransformNodes [0] .transformPoint (texCoord);
-
-      return texCoord;
+      return this .textureTransformNodes [0] .transformPoint (texCoord);
    },
 });
 

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

@@ -138,7 +138,7 @@ TextureCoordinateGenerator .prototype = Object .assign (Object .create (X3DSingl
    {
       array .push (0, 0, 0, 1);
    },
-   setShaderUniformsToChannel: function (gl, shaderObject, channel = 0)
+   setShaderUniforms: function (gl, shaderObject, channel = 0)
    {
       gl .uniform1i  (shaderObject .x3d_TextureCoordinateGeneratorMode [channel],      this .mode);
       gl .uniform1fv (shaderObject .x3d_TextureCoordinateGeneratorParameter [channel], this .parameter);

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

@@ -77,15 +77,9 @@ X3DSingleTextureCoordinateNode .prototype = Object .assign (Object .create (X3DT
    },
    getTextureCoordinateMapping: function (textureCoordinateMapping, channel = 0)
    {
-      if (this ._mapping .getValue ())
-         textureCoordinateMapping .set (this ._mapping .getValue (), channel);
+      textureCoordinateMapping .set (this ._mapping .getValue () || channel, channel);
    },
-   setShaderUniforms: function (gl, shaderObject)
-   {
-      for (let i = 0, length = shaderObject .x3d_MaxTextures; i < length; ++ i)
-         this .setShaderUniformsToChannel (gl, shaderObject, i);
-   },
-   setShaderUniformsToChannel: function (gl, shaderObject, channel = 0)
+   setShaderUniforms: function (gl, shaderObject, channel = 0)
    {
       gl .uniform1i (shaderObject .x3d_TextureCoordinateGeneratorMode [channel], 0);
    },

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

@@ -71,15 +71,9 @@ X3DSingleTextureTransformNode .prototype = Object .assign (Object .create (X3DTe
    },
    getTextureTransformMapping: function (textureTransformMapping, channel = 0)
    {
-      if (this ._mapping .getValue ())
-         textureTransformMapping .set (this ._mapping .getValue (), channel);
+      textureTransformMapping .set (this ._mapping .getValue () || channel, channel);
    },
-   setShaderUniforms: function (gl, shaderObject)
-   {
-      for (let i = 0, length = shaderObject .x3d_MaxTextures; i < length; ++ i)
-         this .setShaderUniformsToChannel (gl, shaderObject, i);
-   },
-   setShaderUniformsToChannel: function (gl, shaderObject, channel = 0)
+   setShaderUniforms: function (gl, shaderObject, channel = 0)
    {
       gl .uniformMatrix4fv (shaderObject .x3d_TextureMatrix [channel], false, this .matrixArray);
    },