x_ite 4.2.17 → 4.7.7

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

@@ -56,8 +56,6 @@ define ([
 	"x_ite/Components/Sound/X3DSoundSourceNode",
 	"x_ite/Components/Networking/X3DUrlObject",
 	"x_ite/Bits/X3DConstants",
-	"x_ite/Browser/Networking/urls",
-	"standard/Networking/URI",
 	"standard/Math/Algorithm",
 	"x_ite/DEBUG",
 ],
@@ -65,12 +63,10 @@ function ($,
           Fields,
           X3DFieldDefinition,
           FieldDefinitionArray,
-          X3DTexture2DNode, 
-          X3DSoundSourceNode, 
-          X3DUrlObject, 
+          X3DTexture2DNode,
+          X3DSoundSourceNode,
+          X3DUrlObject,
           X3DConstants,
-          urls,
-          URI,
           Algorithm,
           DEBUG)
 {
@@ -83,8 +79,8 @@ function ($,
 		X3DUrlObject       .call (this, executionContext);
 
 		this .addType (X3DConstants .MovieTexture);
-		
-		this .addChildObjects ("buffer", new Fields .SFTime ());
+
+		this .addChildObjects ("buffer", new Fields .MFString ());
 
 		this .canvas   = $("<canvas></canvas>");
 		this .video    = $("<video></video>");
@@ -97,25 +93,25 @@ function ($,
 	{
 		constructor: MovieTexture,
 		fieldDefinitions: new FieldDefinitionArray ([
-			new X3DFieldDefinition (X3DConstants .inputOutput,    "metadata",          new Fields .SFNode ()),
-			new X3DFieldDefinition (X3DConstants .inputOutput,    "enabled",           new Fields .SFBool (true)),
-			new X3DFieldDefinition (X3DConstants .inputOutput,    "description",       new Fields .SFString ()),
-			new X3DFieldDefinition (X3DConstants .inputOutput,    "url",               new Fields .MFString ()),
-			new X3DFieldDefinition (X3DConstants .inputOutput,    "speed",             new Fields .SFFloat (1)),
-			new X3DFieldDefinition (X3DConstants .inputOutput,    "pitch",             new Fields .SFFloat (1)),
-			new X3DFieldDefinition (X3DConstants .inputOutput,    "loop",              new Fields .SFBool ()),
-			new X3DFieldDefinition (X3DConstants .inputOutput,    "startTime",         new Fields .SFTime ()),
-			new X3DFieldDefinition (X3DConstants .inputOutput,    "resumeTime",        new Fields .SFTime ()),
-			new X3DFieldDefinition (X3DConstants .inputOutput,    "pauseTime",         new Fields .SFTime ()),
-			new X3DFieldDefinition (X3DConstants .inputOutput,    "stopTime",          new Fields .SFTime ()),
-			new X3DFieldDefinition (X3DConstants .outputOnly,     "isPaused",          new Fields .SFBool ()),
-			new X3DFieldDefinition (X3DConstants .outputOnly,     "isActive",          new Fields .SFBool ()),
-			new X3DFieldDefinition (X3DConstants .outputOnly,     "cycleTime",         new Fields .SFTime ()),
-			new X3DFieldDefinition (X3DConstants .outputOnly,     "elapsedTime",       new Fields .SFTime ()),
-			new X3DFieldDefinition (X3DConstants .outputOnly,     "duration_changed",  new Fields .SFTime (-1)),
-			new X3DFieldDefinition (X3DConstants .initializeOnly, "repeatS",           new Fields .SFBool (true)),
-			new X3DFieldDefinition (X3DConstants .initializeOnly, "repeatT",           new Fields .SFBool (true)),
-			new X3DFieldDefinition (X3DConstants .initializeOnly, "textureProperties", new Fields .SFNode ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "metadata",             new Fields .SFNode ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "description",          new Fields .SFString ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "url",                  new Fields .MFString ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "autoRefresh",          new Fields .SFTime ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "autoRefreshTimeLimit", new Fields .SFTime (3600)),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "speed",                new Fields .SFFloat (1)),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "pitch",                new Fields .SFFloat (1)),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "loop",                 new Fields .SFBool ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "startTime",            new Fields .SFTime ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "resumeTime",           new Fields .SFTime ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "pauseTime",            new Fields .SFTime ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "stopTime",             new Fields .SFTime ()),
+			new X3DFieldDefinition (X3DConstants .outputOnly,     "isPaused",             new Fields .SFBool ()),
+			new X3DFieldDefinition (X3DConstants .outputOnly,     "isActive",             new Fields .SFBool ()),
+			new X3DFieldDefinition (X3DConstants .outputOnly,     "elapsedTime",          new Fields .SFTime ()),
+			new X3DFieldDefinition (X3DConstants .outputOnly,     "duration_changed",     new Fields .SFTime (-1)),
+			new X3DFieldDefinition (X3DConstants .initializeOnly, "repeatS",              new Fields .SFBool (true)),
+			new X3DFieldDefinition (X3DConstants .initializeOnly, "repeatT",              new Fields .SFBool (true)),
+			new X3DFieldDefinition (X3DConstants .initializeOnly, "textureProperties",    new Fields .SFNode ()),
 		]),
 		getTypeName: function ()
 		{
@@ -154,21 +150,22 @@ function ($,
 		{
 			this .setLoadState (X3DConstants .NOT_STARTED_STATE);
 
-			this .requestAsyncLoad ();
+			this .requestImmediateLoad ();
 		},
-		requestAsyncLoad: function ()
+		requestImmediateLoad: function (cache = true)
 		{
 			if (this .checkLoadState () === X3DConstants .COMPLETE_STATE || this .checkLoadState () === X3DConstants .IN_PROGRESS_STATE)
 				return;
 
+			this .setCache (cache);
 			this .setLoadState (X3DConstants .IN_PROGRESS_STATE);
 
-			this .buffer_ .addEvent ();
+			this .buffer_ = this .url_;
 		},
 		set_buffer__: function ()
 		{
 			this .setMedia (null);
-			this .urlStack .setValue (this .url_);
+			this .urlStack .setValue (this .buffer_);
 			this .video .bind ("canplaythrough", this .setVideo .bind (this));
 			this .loadNext ();
 		},
@@ -180,32 +177,23 @@ function ($,
 			   this .duration_changed_ = -1;
 				this .clearTexture ();
 				this .setLoadState (X3DConstants .FAILED_STATE);
-				this .stop ();
 				return;
 			}
 
 			// Get URL.
 
-			this .URL = new URI (this .urlStack .shift ());
-			this .URL = this .getExecutionContext () .getURL () .transform (this .URL);
-	
-			this .video .attr ("src", this .URL);
+			this .URL = new URL (this .urlStack .shift (), this .getExecutionContext () .getWorldURL ());
+
+			if (!this .getBrowser () .getBrowserOptions () .getCache () || !this .getCache ())
+				this .URL .searchParams .set ("_", Date .now ());
+
+			this .video .attr ("src", this .URL .href);
+			this .video .get (0) .load ();
 		},
 		setError: function ()
 		{
-			var URL = this .URL .toString ();
-
-			if (DEBUG)
-			{
-				if (! (this .URL .isLocal () || this .URL .host === "localhost"))
-				{
-					if (! URL .match (urls .fallbackExpression))
-						this .urlStack .unshift (urls .fallbackUrl + URL);
-				}
-			}
-
-			if (this .URL .scheme !== "data")
-				console .warn ("Error loading movie:", this .URL .toString ());
+			if (this .URL .protocol !== "data:")
+				console .warn ("Error loading movie:", this .URL .href);
 
 			this .loadNext ();
 		},
@@ -213,15 +201,15 @@ function ($,
 		{
 			if (DEBUG)
 			{
-				if (this .URL .scheme !== "data")
-					console .info ("Done loading movie:", this .URL .toString ());
+				if (this .URL .protocol !== "data:")
+					console .info ("Done loading movie:", this .URL .href);
 			}
 
 			try
 			{
 				this .video .unbind ("canplaythrough");
 
-				var
+				const
 			      video  = this .video [0],
 					width  = video .videoWidth,
 					height = video .videoHeight,
@@ -236,7 +224,7 @@ function ($,
 
 				cx .drawImage (video, 0, 0);
 
-				var data = cx .getImageData (0, 0, width, height) .data;
+				const data = cx .getImageData (0, 0, width, height) .data;
 
 				setTimeout (function ()
 				{
@@ -265,5 +253,3 @@ function ($,
 
 	return MovieTexture;
 });
-
-

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

@@ -53,12 +53,20 @@ define ([
 	"x_ite/Basic/FieldDefinitionArray",
 	"x_ite/Components/Texturing/X3DTextureNode",
 	"x_ite/Bits/X3DConstants",
+	"x_ite/Bits/X3DCast",
+	"x_ite/Browser/Texturing/MultiTextureModeType",
+	"x_ite/Browser/Texturing/MultiTextureSourceType",
+	"x_ite/Browser/Texturing/MultiTextureFunctionType",
 ],
 function (Fields,
           X3DFieldDefinition,
           FieldDefinitionArray,
-          X3DTextureNode, 
-          X3DConstants)
+          X3DTextureNode,
+          X3DConstants,
+          X3DCast,
+          ModeType,
+          SourceType,
+          FunctionType)
 {
 "use strict";
 
@@ -67,19 +75,29 @@ function (Fields,
 		X3DTextureNode .call (this, executionContext);
 
 		this .addType (X3DConstants .MultiTexture);
+
+		this .addChildObjects ("loadState", new Fields .SFInt32 (X3DConstants .NOT_STARTED_STATE));
+
+		this .color        = new Float32Array (4);
+		this .modes        = [ ];
+		this .alphaModes   = [ ];
+		this .sources      = [ ];
+		this .functions    = [ ];
+		this .textureNodes = [ ];
 	}
 
 	MultiTexture .prototype = Object .assign (Object .create (X3DTextureNode .prototype),
 	{
 		constructor: MultiTexture,
 		fieldDefinitions: new FieldDefinitionArray ([
-			new X3DFieldDefinition (X3DConstants .inputOutput, "metadata", new Fields .SFNode ()),
-			new X3DFieldDefinition (X3DConstants .inputOutput, "color",    new Fields .SFColor (1, 1, 1)),
-			new X3DFieldDefinition (X3DConstants .inputOutput, "alpha",    new Fields .SFFloat (1)),
-			new X3DFieldDefinition (X3DConstants .inputOutput, "mode",     new Fields .MFString ()),
-			new X3DFieldDefinition (X3DConstants .inputOutput, "source",   new Fields .MFString ()),
-			new X3DFieldDefinition (X3DConstants .inputOutput, "function", new Fields .MFString ()),
-			new X3DFieldDefinition (X3DConstants .inputOutput, "texture",  new Fields .MFNode ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput, "metadata",    new Fields .SFNode ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput, "description", new Fields .SFString ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput, "color",       new Fields .SFColor (1, 1, 1)),
+			new X3DFieldDefinition (X3DConstants .inputOutput, "alpha",       new Fields .SFFloat (1)),
+			new X3DFieldDefinition (X3DConstants .inputOutput, "mode",        new Fields .MFString ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput, "source",      new Fields .MFString ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput, "function",    new Fields .MFString ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput, "texture",     new Fields .MFNode ()),
 		]),
 		getTypeName: function ()
 		{
@@ -93,9 +111,216 @@ function (Fields,
 		{
 			return "texture";
 		},
+		initialize: function ()
+		{
+			X3DTextureNode .prototype .initialize .call (this);
+
+			this .color_    .addInterest ("set_color__",    this);
+			this .alpha_    .addInterest ("set_alpha__",    this);
+			this .mode_     .addInterest ("set_mode__",     this);
+			this .source_   .addInterest ("set_source__",   this);
+			this .function_ .addInterest ("set_function__", this);
+			this .texture_  .addInterest ("set_texture__",  this);
+
+			this .set_color__ ();
+			this .set_alpha__ ();
+			this .set_mode__ ();
+			this .set_source__ ();
+			this .set_function__ ();
+			this .set_texture__ ();
+
+			this .loadState_ = X3DConstants .COMPLETE_STATE;
+		},
+		getMode: function (index)
+		{
+			if (index < this .modes .length)
+				return this .modes [index];
+
+			return ModeType .MODULATE;
+		},
+		getAlphaMode: function (index)
+		{
+			if (index < this .alphaModes .length)
+				return this .alphaModes [index];
+
+			return ModeType .MODULATE;
+		},
+		getSource: function (index)
+		{
+			if (index < this .sources .length)
+				return this .sources [index];
+
+			return SourceType .DEFAULT;
+		},
+		getFunction: function (index)
+		{
+			if (index < this .functions .length)
+				return this .functions [index];
+
+			return FunctionType .DEFAULT;
+		},
+		set_color__: function ()
+		{
+			this .color [0] = this .color_ .r;
+			this .color [1] = this .color_ .g;
+			this .color [2] = this .color_ .b;
+		},
+		set_alpha__: function ()
+		{
+			this .color [3] = this .alpha_;
+		},
+		set_mode__: (function ()
+		{
+			var modeTypes = new Map ([
+				["REPLACE",                   ModeType .REPLACE],
+				["MODULATE",                  ModeType .MODULATE],
+				["MODULATE2X",                ModeType .MODULATE2X],
+				["MODULATE4X",                ModeType .MODULATE4X],
+				["ADD",                       ModeType .ADD],
+				["ADDSIGNED",                 ModeType .ADDSIGNED],
+				["ADDSIGNED2X",               ModeType .ADDSIGNED2X],
+				["ADDSMOOTH",                 ModeType .ADDSMOOTH],
+				["SUBTRACT",                  ModeType .SUBTRACT],
+				["BLENDDIFFUSEALPHA",         ModeType .BLENDDIFFUSEALPHA],
+				["BLENDTEXTUREALPHA",         ModeType .BLENDTEXTUREALPHA],
+				["BLENDFACTORALPHA",          ModeType .BLENDFACTORALPHA],
+				["BLENDCURRENTALPHA",         ModeType .BLENDCURRENTALPHA],
+				["MODULATEALPHA_ADDCOLOR",    ModeType .MODULATEALPHA_ADDCOLOR],
+				["MODULATEINVALPHA_ADDCOLOR", ModeType .MODULATEINVALPHA_ADDCOLOR],
+				["MODULATEINVCOLOR_ADDALPHA", ModeType .MODULATEINVCOLOR_ADDALPHA],
+				["DOTPRODUCT3",               ModeType .DOTPRODUCT3],
+				["SELECTARG1",                ModeType .SELECTARG1],
+				["SELECTARG2",                ModeType .SELECTARG2],
+				["OFF",                       ModeType .OFF],
+			]);
+
+			return function ()
+			{
+				this .modes      .length = 0;
+				this .alphaModes .length = 0;
+
+				for (var i = 0, length = this .mode_ .length; i < length; ++ i)
+				{
+					var mode = this .mode_ [i] .split (",");
+
+					for (var m = 0, mLength = mode .length; m < mLength; ++ m)
+						mode [m] = mode [m] .trim ();
+
+					if (mode .length === 0)
+						mode .push ("MODULATE");
+
+					if (mode .length < 2)
+						mode .push (mode [0]);
+
+					// RGB
+
+					var modeType = modeTypes .get (mode [0]);
+
+					if (modeType !== undefined)
+						this .modes .push (modeType);
+					else
+						this .modes .push (ModeType .MODULATE);
+
+					// Alpha
+
+					var modeType = modeTypes .get (mode [1]);
+
+					if (modeType !== undefined)
+						this .alphaModes .push (modeType);
+					else
+						this .alphaModes .push (ModeType .MODULATE);
+				}
+			};
+		})(),
+		set_source__: (function ()
+		{
+			var sourceTypes = new Map ([
+				["DIFFUSE",  SourceType .DIFFUSE],
+				["SPECULAR", SourceType .SPECULAR],
+				["FACTOR",   SourceType .FACTOR],
+			]);
+
+			return function ()
+			{
+				this .sources .length = 0;
+
+				for (var i = 0, length = this .source_ .length; i < length; ++ i)
+				{
+					var sourceType = sourceTypes .get (this .source_ [i]);
+
+					if (sourceType !== undefined)
+						this .sources .push (sourceType);
+					else
+						this .sources .push (SourceType .DEFAULT);
+				}
+			};
+		})(),
+		set_function__: (function ()
+		{
+			var functionsTypes = new Map ([
+				["COMPLEMENT",     FunctionType .COMPLEMENT],
+				["ALPHAREPLICATE", FunctionType .ALPHAREPLICATE],
+			]);
+
+			return function ()
+			{
+				this .functions .length = 0;
+
+				for (var i = 0, length = this .function_ .length; i < length; ++ i)
+				{
+					var functionsType = functionsTypes .get (this .function_ [i]);
+
+					if (functionsType !== undefined)
+						this .functions .push (functionsType);
+					else
+						this .functions .push (FunctionType .DEFAULT);
+				}
+			};
+		})(),
+		set_texture__: function ()
+		{
+			this .textureNodes .length = 0;
+
+			for (var i = 0, length = this .texture_ .length; i < length; ++ i)
+			{
+				var node = this .texture_ [i];
+
+				if (X3DCast (X3DConstants .MultiTexture, node))
+					continue;
+
+				var textureNode = X3DCast (X3DConstants .X3DTextureNode, node);
+
+				if (textureNode)
+					this .textureNodes .push (textureNode);
+			}
+		},
+		traverse: function (type, renderObject)
+		{
+			var textureNodes = this .textureNodes;
+
+			for (var i = 0, length = textureNodes .length; i < length; ++ i)
+				textureNodes [i] .traverse (type, renderObject);
+		},
+		setShaderUniforms: function (gl, shaderObject, renderObject)
+		{
+			var
+				textureNodes = this .textureNodes,
+				channels     = Math .min (shaderObject .getBrowser () .getMaxTextures (), textureNodes .length);
+
+			gl .uniform1i  (shaderObject .x3d_NumTextures,       channels);
+			gl .uniform4fv (shaderObject .x3d_MultiTextureColor, this .color);
+
+			for (var i = 0; i < channels; ++ i)
+			{
+				textureNodes [i] .setShaderUniformsToChannel (gl, shaderObject, renderObject, i);
+
+				gl .uniform1i  (shaderObject .x3d_MultiTextureMode [i],      this .getMode (i));
+				gl .uniform1i  (shaderObject .x3d_MultiTextureAlphaMode [i], this .getAlphaMode (i));
+				gl .uniform1i  (shaderObject .x3d_MultiTextureSource [i],    this .getSource (i));
+				gl .uniform1i  (shaderObject .x3d_MultiTextureFunction [i],  this .getFunction (i));
+			}
+		},
 	});
 
 	return MultiTexture;
 });
-
-

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

@@ -53,12 +53,14 @@ define ([
 	"x_ite/Basic/FieldDefinitionArray",
 	"x_ite/Components/Texturing/X3DTextureCoordinateNode",
 	"x_ite/Bits/X3DConstants",
+	"x_ite/Bits/X3DCast",
 ],
 function (Fields,
           X3DFieldDefinition,
           FieldDefinitionArray,
-          X3DTextureCoordinateNode, 
-          X3DConstants)
+          X3DTextureCoordinateNode,
+          X3DConstants,
+          X3DCast)
 {
 "use strict";
 
@@ -67,6 +69,8 @@ function (Fields,
 		X3DTextureCoordinateNode .call (this, executionContext);
 
 		this .addType (X3DConstants .MultiTextureCoordinate);
+
+		this .textureCoordinateNodes = [ ];
 	}
 
 	MultiTextureCoordinate .prototype = Object .assign (Object .create (X3DTextureCoordinateNode .prototype),
@@ -88,9 +92,36 @@ function (Fields,
 		{
 			return "texCoord";
 		},
-		getTexCoord: function (array)
+		initialize: function ()
 		{
-			return array;
+			X3DTextureCoordinateNode .prototype .initialize .call (this);
+
+			this .texCoord_ .addInterest ("set_texCoord__", this);
+
+			this .set_texCoord__ ();
+		},
+		set_texCoord__: function ()
+		{
+			const textureCoordinateNodes = this .textureCoordinateNodes;
+
+			for (const textureCoordinateNode of textureCoordinateNodes)
+				textureCoordinateNode .removeInterest ("addNodeEvent", this);
+
+			textureCoordinateNodes .length = 0;
+
+			for (const node of this .texCoord_)
+			{
+				if (X3DCast (X3DConstants .MultiTextureCoordinate, node))
+					continue;
+
+				const textureCoordinateNode = X3DCast (X3DConstants .X3DTextureCoordinateNode, node);
+
+				if (textureCoordinateNode)
+					textureCoordinateNodes .push (textureCoordinateNode);
+			}
+
+			for (const textureCoordinateNode of textureCoordinateNodes)
+				textureCoordinateNode .addInterest ("addNodeEvent", this);
 		},
 		isEmpty: function ()
 		{
@@ -102,11 +133,47 @@ function (Fields,
 		},
 		get1Point: function (index, vector)
 		{
+			for (const textureCoordinateNode of this .textureCoordinateNodes)
+				return textureCoordinateNode .get1Point (index, vector);
+
 			return vector .set (0, 0, 0, 1);
 		},
+		init: function (multiArray)
+		{
+			for (const textureCoordinateNode of this .textureCoordinateNodes)
+				textureCoordinateNode .init (multiArray);
+		},
+		addTexCoord: function (index, multiArray)
+		{
+			const textureCoordinateNodes = this .textureCoordinateNodes;
+
+			for (let i = 0, length = textureCoordinateNodes .length; i < length; ++ i)
+				textureCoordinateNodes [i] .addTexCoordToChannel (index, multiArray [i]);
+		},
+		addTexCoordToChannel: function (index, array)
+		{ },
+		getTexCoord: function (array)
+		{
+			for (const textureCoordinateNode of this .textureCoordinateNodes)
+				return textureCoordinateNode .getTexCoord (array);
+
+			return array;
+		},
+		setShaderUniforms: function (gl, shaderObject)
+		{
+			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);
+
+			const last = length ? textureCoordinateNodes .at (-1) : this;
+
+			for (let i = length, l = shaderObject .x3d_MaxTextures; i < l; ++ i)
+				textureCoordinateNodes [last] .setShaderUniformsToChannel (gl, shaderObject, i);
+		},
 	});
 
 	return MultiTextureCoordinate;
 });
-
-

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

@@ -53,12 +53,14 @@ define ([
 	"x_ite/Basic/FieldDefinitionArray",
 	"x_ite/Components/Texturing/X3DTextureTransformNode",
 	"x_ite/Bits/X3DConstants",
+	"x_ite/Bits/X3DCast",
 ],
 function (Fields,
           X3DFieldDefinition,
           FieldDefinitionArray,
-          X3DTextureTransformNode, 
-          X3DConstants)
+          X3DTextureTransformNode,
+          X3DConstants,
+          X3DCast)
 {
 "use strict";
 
@@ -67,6 +69,8 @@ function (Fields,
 		X3DTextureTransformNode .call (this, executionContext);
 
 		this .addType (X3DConstants .MultiTextureTransform);
+
+		this .textureTransformNodes = [ ];
 	}
 
 	MultiTextureTransform .prototype = Object .assign (Object .create (X3DTextureTransformNode .prototype),
@@ -88,9 +92,46 @@ function (Fields,
 		{
 			return "textureTransform";
 		},
+		initialize: function ()
+		{
+			X3DTextureTransformNode .prototype .initialize .call (this);
+
+			this .textureTransform_ .addInterest ("set_textureTransform_", this);
+
+			this .set_textureTransform__ ();
+		},
+		set_textureTransform__: function ()
+		{
+			const textureTransformNodes = this .textureTransformNodes;
+
+			textureTransformNodes .length = 0;
+
+			for (const node of this .textureTransform_)
+			{
+				if (X3DCast (X3DConstants .MultiTextureTransform, node))
+					continue;
+
+				const textureTransformNode = X3DCast (X3DConstants .X3DTextureTransformNode, node);
+
+				if (textureTransformNode)
+					textureTransformNodes .push (textureTransformNode);
+			}
+		},
+		setShaderUniforms: 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);
+
+			const last = length ? textureTransformNodes .at (-1) : this;
+
+			for (let i = length, l = shaderObject .x3d_MaxTextures; i < l; ++ i)
+				last .setShaderUniformsToChannel (gl, shaderObject, i);
+		},
 	});
 
 	return MultiTextureTransform;
 });
-
-