x_ite 4.7.12 → 5.0.0

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

@@ -48,12 +48,12 @@
 
 
  define ([
-	"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",
+   "x_ite/Components/Texturing/X3DTextureNode",
+   "x_ite/Base/X3DConstants",
+   "x_ite/Base/X3DCast",
+   "x_ite/Browser/Texturing/MultiTextureModeType",
+   "x_ite/Browser/Texturing/MultiTextureSourceType",
+   "x_ite/Browser/Texturing/MultiTextureFunctionType",
 ],
 function (X3DTextureNode,
           X3DConstants,
@@ -64,47 +64,47 @@ function (X3DTextureNode,
 {
 "use strict";
 
-	function X3DSingleTextureNode (executionContext)
-	{
-		X3DTextureNode .call (this, executionContext);
+   function X3DSingleTextureNode (executionContext)
+   {
+      X3DTextureNode .call (this, executionContext);
 
-		this .addType (X3DConstants .X3DSingleTextureNode);
-	}
+      this .addType (X3DConstants .X3DSingleTextureNode);
+   }
 
-	X3DSingleTextureNode .prototype = Object .assign (Object .create (X3DTextureNode .prototype),
-	{
-		constructor: X3DSingleTextureNode,
-		initialize: function ()
-		{
-			X3DTextureNode .prototype .initialize .call (this);
+   X3DSingleTextureNode .prototype = Object .assign (Object .create (X3DTextureNode .prototype),
+   {
+      constructor: X3DSingleTextureNode,
+      initialize: function ()
+      {
+         X3DTextureNode .prototype .initialize .call (this);
 
-			this .textureProperties_ .addInterest ("set_textureProperties__", this);
+         this ._textureProperties .addInterest ("set_textureProperties__", this);
 
-			const gl = this .getBrowser () .getContext ();
+         const gl = this .getBrowser () .getContext ();
 
-			this .texture = gl .createTexture ();
+         this .texture = gl .createTexture ();
 
-			this .set_textureProperties__ ();
-		},
-		set_textureProperties__: function ()
-		{
-			if (this .texturePropertiesNode)
-				this .texturePropertiesNode .removeInterest ("updateTextureProperties", this);
+         this .set_textureProperties__ ();
+      },
+      set_textureProperties__: function ()
+      {
+         if (this .texturePropertiesNode)
+            this .texturePropertiesNode .removeInterest ("updateTextureProperties", this);
 
-			this .texturePropertiesNode = X3DCast (X3DConstants .TextureProperties, this .textureProperties_);
+         this .texturePropertiesNode = X3DCast (X3DConstants .TextureProperties, this ._textureProperties);
 
-			if (! this .texturePropertiesNode)
-				this .texturePropertiesNode = this .getBrowser () .getDefaultTextureProperties ();
+         if (! this .texturePropertiesNode)
+            this .texturePropertiesNode = this .getBrowser () .getDefaultTextureProperties ();
 
-			this .texturePropertiesNode .addInterest ("updateTextureProperties", this);
+         this .texturePropertiesNode .addInterest ("updateTextureProperties", this);
 
-			this .updateTextureProperties ();
-		},
-		getTexture: function ()
-		{
-			return this .texture;
-		},
-		updateTextureProperties: (function ()
+         this .updateTextureProperties ();
+      },
+      getTexture: function ()
+      {
+         return this .texture;
+      },
+      updateTextureProperties: (function ()
       {
          // Anisotropic Filtering in WebGL is handled by an extension, use one of getExtension depending on browser:
 
@@ -128,7 +128,7 @@ function (X3DTextureNode,
             }
             else
             {
-               if (textureProperties .generateMipMaps_ .getValue ())
+               if (textureProperties ._generateMipMaps .getValue ())
                   gl .generateMipmap (target);
 
                gl .texParameteri (target, gl .TEXTURE_MIN_FILTER, gl [textureProperties .getMinificationFilter ()]);
@@ -152,8 +152,8 @@ function (X3DTextureNode,
                   gl .texParameteri (target, gl .TEXTURE_WRAP_R, repeatR ? gl .REPEAT : gl .CLAMP_TO_EDGE);
             }
 
-            //gl .texParameterfv (target, gl .TEXTURE_BORDER_COLOR, textureProperties .borderColor_ .getValue ());
-            //gl .texParameterf  (target, gl .TEXTURE_PRIORITY,     textureProperties .texturePriority_ .getValue ());
+            //gl .texParameterfv (target, gl .TEXTURE_BORDER_COLOR, textureProperties ._borderColor .getValue ());
+            //gl .texParameterf  (target, gl .TEXTURE_PRIORITY,     textureProperties ._texturePriority .getValue ());
 
             for (const extension of ANISOTROPIC_EXT)
             {
@@ -161,23 +161,23 @@ function (X3DTextureNode,
 
                if (ext)
                {
-                  gl .texParameterf (target, ext .TEXTURE_MAX_ANISOTROPY_EXT, textureProperties .anisotropicDegree_ .getValue ());
+                  gl .texParameterf (target, ext .TEXTURE_MAX_ANISOTROPY_EXT, textureProperties ._anisotropicDegree .getValue ());
                   break;
                }
             }
          };
       })(),
-		setShaderUniforms: function (gl, shaderObject, renderObject)
-		{
-			this .setShaderUniformsToChannel (gl, shaderObject, renderObject, 0);
-
-			gl .uniform1i (shaderObject .x3d_NumTextures, 1);
-			gl .uniform1i (shaderObject .x3d_MultiTextureMode [0],      ModeType .MODULATE);
-			gl .uniform1i (shaderObject .x3d_MultiTextureAlphaMode [0], ModeType .MODULATE);
-			gl .uniform1i (shaderObject .x3d_MultiTextureSource [0],    SourceType .DEFAULT);
-			gl .uniform1i (shaderObject .x3d_MultiTextureFunction [0],  FunctionType .DEFAULT);
-		},
-	});
-
-	return X3DSingleTextureNode;
+      setShaderUniforms: function (gl, shaderObject, renderObject)
+      {
+         this .setShaderUniformsToChannel (gl, shaderObject, renderObject, shaderObject .x3d_Textures [0]);
+
+         gl .uniform1i (shaderObject .x3d_NumTextures, 1);
+         gl .uniform1i (shaderObject .x3d_MultiTextureMode [0],      ModeType .MODULATE);
+         gl .uniform1i (shaderObject .x3d_MultiTextureAlphaMode [0], ModeType .MODULATE);
+         gl .uniform1i (shaderObject .x3d_MultiTextureSource [0],    SourceType .DEFAULT);
+         gl .uniform1i (shaderObject .x3d_MultiTextureFunction [0],  FunctionType .DEFAULT);
+      },
+   });
+
+   return X3DSingleTextureNode;
 });

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

@@ -48,30 +48,35 @@
 
 
  define ([
-	"x_ite/Components/Texturing/X3DTextureTransformNode",
-	"x_ite/Bits/X3DConstants",
+   "x_ite/Components/Texturing/X3DTextureTransformNode",
+   "x_ite/Base/X3DConstants",
 ],
 function (X3DTextureTransformNode,
           X3DConstants)
 {
 "use strict";
 
-	function X3DSingleTextureTransformNode (executionContext)
-	{
-		X3DTextureTransformNode .call (this, executionContext);
+   function X3DSingleTextureTransformNode (executionContext)
+   {
+      X3DTextureTransformNode .call (this, executionContext);
 
-		this .addType (X3DConstants .X3DSingleTextureTransformNode);
-	}
+      this .addType (X3DConstants .X3DSingleTextureTransformNode);
+   }
 
-	X3DSingleTextureTransformNode .prototype = Object .assign (Object .create (X3DTextureTransformNode .prototype),
-	{
-		constructor: X3DSingleTextureTransformNode,
-		setShaderUniforms: function (gl, shaderObject)
-		{
-			for (let i = 0, length = shaderObject .x3d_MaxTextures; i < length; ++ i)
-				this .setShaderUniformsToChannel (gl, shaderObject, i);
-		},
-	});
+   X3DSingleTextureTransformNode .prototype = Object .assign (Object .create (X3DTextureTransformNode .prototype),
+   {
+      constructor: X3DSingleTextureTransformNode,
+      getTextureMapping: function (textureTransformMapping, channel = 0)
+      {
+         if (this ._mapping .getValue ())
+            textureTransformMapping .set (this ._mapping .getValue (), channel);
+      },
+      setShaderUniforms: function (gl, shaderObject)
+      {
+         for (let i = 0, length = shaderObject .x3d_MaxTextures; i < length; ++ i)
+            this .setShaderUniformsToChannel (gl, shaderObject, i);
+      },
+   });
 
-	return X3DSingleTextureTransformNode;
+   return X3DSingleTextureTransformNode;
 });

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

@@ -48,134 +48,145 @@
 
 
 define ([
-	"x_ite/Components/Texturing/X3DSingleTextureNode",
-	"x_ite/Bits/X3DConstants",
+   "x_ite/Components/Texturing/X3DSingleTextureNode",
+   "x_ite/Base/X3DConstants",
 ],
 function (X3DSingleTextureNode,
           X3DConstants)
 {
 "use strict";
 
-   var defaultData = new Uint8Array ([ 255, 255, 255, 255 ]);
-
-	function X3DTexture2DNode (executionContext)
-	{
-		X3DSingleTextureNode .call (this, executionContext);
-
-		this .addType (X3DConstants .X3DTexture2DNode);
-
-		const gl = this .getBrowser () .getContext ();
-
-		this .target = gl .TEXTURE_2D;
-		this .width  = 0;
-		this .height = 0;
-		this .flipY  = false;
-		this .data   = null;
-	}
-
-	X3DTexture2DNode .prototype = Object .assign (Object .create (X3DSingleTextureNode .prototype),
-	{
-		constructor: X3DTexture2DNode,
-		initialize: function ()
-		{
-			X3DSingleTextureNode .prototype .initialize .call (this);
-
-			this .repeatS_ .addInterest ("updateTextureProperties", this);
-			this .repeatT_ .addInterest ("updateTextureProperties", this);
-
-			const gl = this .getBrowser () .getContext ();
-
-			gl .bindTexture (gl .TEXTURE_2D, this .getTexture ());
-			gl .texImage2D  (gl .TEXTURE_2D, 0, gl .RGBA, 1, 1, 0, gl .RGBA, gl .UNSIGNED_BYTE, defaultData);
-		},
-		getTarget: function ()
-		{
-			return this .target;
-		},
-		getWidth: function ()
-		{
-			return this .width;
-		},
-		getHeight: function ()
-		{
-			return this .height;
-		},
-		getFlipY: function ()
-		{
-			return this .flipY;
-		},
-		getData: function ()
-		{
-			return this .data;
-		},
-		clearTexture: function ()
-		{
-			this .setTexture (1, 1, false, defaultData, false);
-
-			this .data = null;
-		},
-		setTexture: function (width, height, transparent, data, flipY)
-		{
-			try
-			{
-				this .width  = width;
-				this .height = height;
-				this .flipY  = flipY;
-				this .data   = data;
-
-				var gl = this .getBrowser () .getContext ();
-
-				gl .pixelStorei (gl .UNPACK_FLIP_Y_WEBGL, flipY);
-				gl .pixelStorei (gl .UNPACK_ALIGNMENT, 1);
-				gl .bindTexture (gl .TEXTURE_2D, this .getTexture ());
-				gl .texImage2D  (gl .TEXTURE_2D, 0, gl .RGBA, width, height, 0, gl .RGBA, gl .UNSIGNED_BYTE, data);
-
-				this .setTransparent (transparent);
-				this .updateTextureProperties ();
-				this .addNodeEvent ();
-			}
-			catch (error)
-			{ }
-		},
-		updateTexture: function (data, flipY)
-		{
-			try
-			{
-				this .data = data;
-
-				var gl = this .getBrowser () .getContext ();
-
-				gl .pixelStorei (gl .UNPACK_FLIP_Y_WEBGL, flipY);
-				gl .bindTexture (gl .TEXTURE_2D, this .getTexture ());
-				gl .texSubImage2D (gl .TEXTURE_2D, 0, 0, 0, gl .RGBA, gl .UNSIGNED_BYTE, data);
-
-				if (this .texturePropertiesNode .generateMipMaps_ .getValue ())
-					gl .generateMipmap (gl .TEXTURE_2D);
-
-				this .addNodeEvent ();
-			}
-			catch (error)
-			{ }
-		},
-		updateTextureProperties: function ()
-		{
-			X3DSingleTextureNode .prototype .updateTextureProperties .call (this,
-			                                                                this .target,
-			                                                                this .textureProperties_ .getValue (),
-			                                                                this .texturePropertiesNode,
-			                                                                this .width,
-			                                                                this .height,
-			                                                                this .repeatS_ .getValue (),
-			                                                                this .repeatT_ .getValue (),
-			                                                                false);
-		},
-		setShaderUniformsToChannel: function (gl, shaderObject, renderObject, i)
-		{
-			gl .activeTexture (gl .TEXTURE0 + shaderObject .getBrowser () .getTexture2DUnits () [i]);
-			gl .bindTexture (gl .TEXTURE_2D, this .getTexture ());
-			gl .uniform1i (shaderObject .x3d_TextureType [i], 2);
-		},
-	});
-
-	return X3DTexture2DNode;
+   const defaultData = new Uint8Array ([ 255, 255, 255, 255 ]);
+
+   function X3DTexture2DNode (executionContext)
+   {
+      X3DSingleTextureNode .call (this, executionContext);
+
+      this .addType (X3DConstants .X3DTexture2DNode);
+
+      const gl = this .getBrowser () .getContext ();
+
+      this .target = gl .TEXTURE_2D;
+      this .width  = 0;
+      this .height = 0;
+      this .flipY  = false;
+      this .data   = null;
+   }
+
+   X3DTexture2DNode .prototype = Object .assign (Object .create (X3DSingleTextureNode .prototype),
+   {
+      constructor: X3DTexture2DNode,
+      initialize: function ()
+      {
+         X3DSingleTextureNode .prototype .initialize .call (this);
+
+         this ._repeatS .addInterest ("updateTextureProperties", this);
+         this ._repeatT .addInterest ("updateTextureProperties", this);
+
+         const gl = this .getBrowser () .getContext ();
+
+         gl .bindTexture (gl .TEXTURE_2D, this .getTexture ());
+         gl .texImage2D  (gl .TEXTURE_2D, 0, gl .RGBA, 1, 1, 0, gl .RGBA, gl .UNSIGNED_BYTE, defaultData);
+      },
+      getTarget: function ()
+      {
+         return this .target;
+      },
+      getTextureType: function ()
+      {
+         return 2;
+      },
+      getTextureTypeString: function ()
+      {
+         return "2D";
+      },
+      getWidth: function ()
+      {
+         return this .width;
+      },
+      getHeight: function ()
+      {
+         return this .height;
+      },
+      getFlipY: function ()
+      {
+         return this .flipY;
+      },
+      getData: function ()
+      {
+         return this .data;
+      },
+      clearTexture: function ()
+      {
+         this .setTexture (1, 1, false, defaultData, false);
+
+         this .data = null;
+      },
+      setTexture: function (width, height, transparent, data, flipY)
+      {
+         try
+         {
+            this .width  = width;
+            this .height = height;
+            this .flipY  = flipY;
+            this .data   = data;
+
+            const gl = this .getBrowser () .getContext ();
+
+            gl .pixelStorei (gl .UNPACK_FLIP_Y_WEBGL, flipY);
+            gl .pixelStorei (gl .UNPACK_ALIGNMENT, 1);
+            gl .bindTexture (gl .TEXTURE_2D, this .getTexture ());
+            gl .texImage2D  (gl .TEXTURE_2D, 0, gl .RGBA, width, height, 0, gl .RGBA, gl .UNSIGNED_BYTE, data);
+
+            this .setTransparent (transparent);
+            this .updateTextureProperties ();
+            this .addNodeEvent ();
+         }
+         catch (error)
+         { }
+      },
+      updateTexture: function (data, flipY)
+      {
+         try
+         {
+            this .data = data;
+
+            const gl = this .getBrowser () .getContext ();
+
+            gl .pixelStorei (gl .UNPACK_FLIP_Y_WEBGL, flipY);
+            gl .bindTexture (gl .TEXTURE_2D, this .getTexture ());
+            gl .texSubImage2D (gl .TEXTURE_2D, 0, 0, 0, gl .RGBA, gl .UNSIGNED_BYTE, data);
+
+            if (this .texturePropertiesNode ._generateMipMaps .getValue ())
+               gl .generateMipmap (gl .TEXTURE_2D);
+
+            this .addNodeEvent ();
+         }
+         catch (error)
+         { }
+      },
+      updateTextureProperties: function ()
+      {
+         X3DSingleTextureNode .prototype .updateTextureProperties .call (this,
+                                                                         this .target,
+                                                                         this ._textureProperties .getValue (),
+                                                                         this .texturePropertiesNode,
+                                                                         this .width,
+                                                                         this .height,
+                                                                         this ._repeatS .getValue (),
+                                                                         this ._repeatT .getValue (),
+                                                                         false);
+      },
+      setShaderUniformsToChannel: function (gl, shaderObject, renderObject, channel)
+      {
+         const textureUnit = renderObject .getBrowser () .getTexture2DUnit ();
+
+         gl .activeTexture (gl .TEXTURE0 + textureUnit);
+         gl .bindTexture (gl .TEXTURE_2D, this .getTexture ());
+         gl .uniform1i (channel .textureType, 2);
+         gl .uniform1i (channel .texture2D, textureUnit);
+      },
+   });
+
+   return X3DTexture2DNode;
 });

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

@@ -48,29 +48,29 @@
 
 
 define ([
-	"x_ite/Components/Rendering/X3DGeometricPropertyNode",
-	"x_ite/Bits/X3DConstants",
+   "x_ite/Components/Rendering/X3DGeometricPropertyNode",
+   "x_ite/Base/X3DConstants",
 ],
 function (X3DGeometricPropertyNode,
           X3DConstants)
 {
 "use strict";
 
-	function X3DTextureCoordinateNode (executionContext)
-	{
-		X3DGeometricPropertyNode .call (this, executionContext);
+   function X3DTextureCoordinateNode (executionContext)
+   {
+      X3DGeometricPropertyNode .call (this, executionContext);
 
-		this .addType (X3DConstants .X3DTextureCoordinateNode);
-	}
+      this .addType (X3DConstants .X3DTextureCoordinateNode);
+   }
 
-	X3DTextureCoordinateNode .prototype = Object .assign (Object .create (X3DGeometricPropertyNode .prototype),
-	{
-		constructor: X3DTextureCoordinateNode,
-		setShaderUniformsToChannel: function (gl, shaderObject, i)
-		{
-			gl .uniform1i (shaderObject .x3d_TextureCoordinateGeneratorMode [i], 0);
-		},
-	});
+   X3DTextureCoordinateNode .prototype = Object .assign (Object .create (X3DGeometricPropertyNode .prototype),
+   {
+      constructor: X3DTextureCoordinateNode,
+      setShaderUniformsToChannel: function (gl, shaderObject, i)
+      {
+         gl .uniform1i (shaderObject .x3d_TextureCoordinateGeneratorMode [i], 0);
+      },
+   });
 
-	return X3DTextureCoordinateNode;
+   return X3DTextureCoordinateNode;
 });

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

@@ -48,9 +48,9 @@
 
 
 define ([
-	"x_ite/Fields",
-	"x_ite/Components/Shape/X3DAppearanceChildNode",
-	"x_ite/Bits/X3DConstants",
+   "x_ite/Fields",
+   "x_ite/Components/Shape/X3DAppearanceChildNode",
+   "x_ite/Base/X3DConstants",
 ],
 function (Fields,
           X3DAppearanceChildNode,
@@ -58,30 +58,30 @@ function (Fields,
 {
 "use strict";
 
-	function X3DTextureNode (executionContext)
-	{
-		X3DAppearanceChildNode .call (this, executionContext);
+   function X3DTextureNode (executionContext)
+   {
+      X3DAppearanceChildNode .call (this, executionContext);
 
-		this .addType (X3DConstants .X3DTextureNode);
+      this .addType (X3DConstants .X3DTextureNode);
 
-		this .addChildObjects ("transparent", new Fields .SFBool ());
+      this .addChildObjects ("transparent", new Fields .SFBool ());
 
-		this .transparent_ .setAccessType (X3DConstants .outputOnly);
-	}
+      this ._transparent .setAccessType (X3DConstants .outputOnly);
+   }
 
-	X3DTextureNode .prototype = Object .assign (Object .create (X3DAppearanceChildNode .prototype),
-	{
-		constructor: X3DTextureNode,
-		setTransparent: function (value)
-		{
-			if (value !== this .transparent_ .getValue ())
-				this .transparent_ = value;
-		},
-		getTransparent: function ()
-		{
-			return this .transparent_ .getValue ();
-		},
-	});
+   X3DTextureNode .prototype = Object .assign (Object .create (X3DAppearanceChildNode .prototype),
+   {
+      constructor: X3DTextureNode,
+      setTransparent: function (value)
+      {
+         if (value !== this ._transparent .getValue ())
+            this ._transparent = value;
+      },
+      getTransparent: function ()
+      {
+         return this ._transparent .getValue ();
+      },
+   });
 
-	return X3DTextureNode;
+   return X3DTextureNode;
 });

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

@@ -48,9 +48,9 @@
 
 
 define ([
-	"x_ite/Components/Shape/X3DAppearanceChildNode",
-	"x_ite/Bits/X3DConstants",
-	"standard/Math/Numbers/Matrix4",
+   "x_ite/Components/Shape/X3DAppearanceChildNode",
+   "x_ite/Base/X3DConstants",
+   "standard/Math/Numbers/Matrix4",
 ],
 function (X3DAppearanceChildNode,
           X3DConstants,
@@ -58,27 +58,27 @@ function (X3DAppearanceChildNode,
 {
 "use strict";
 
-	function X3DTextureTransformNode (executionContext)
-	{
-		X3DAppearanceChildNode .call (this, executionContext);
+   function X3DTextureTransformNode (executionContext)
+   {
+      X3DAppearanceChildNode .call (this, executionContext);
 
-		this .addType (X3DConstants .X3DTextureTransformNode);
+      this .addType (X3DConstants .X3DTextureTransformNode);
 
-		this .matrixArray = new Float32Array (Matrix4 .Identity);
-	}
+      this .matrixArray = new Float32Array (Matrix4 .Identity);
+   }
 
-	X3DTextureTransformNode .prototype = Object .assign (Object .create (X3DAppearanceChildNode .prototype),
-	{
-		constructor: X3DTextureTransformNode,
-		setMatrix: function (value)
-		{
-			this .matrixArray .set (value);
-		},
-		setShaderUniformsToChannel: function (gl, shaderObject, i)
-		{
-			gl .uniformMatrix4fv (shaderObject .x3d_TextureMatrix [i], false, this .matrixArray);
-		},
-	});
+   X3DTextureTransformNode .prototype = Object .assign (Object .create (X3DAppearanceChildNode .prototype),
+   {
+      constructor: X3DTextureTransformNode,
+      setMatrix: function (value)
+      {
+         this .matrixArray .set (value);
+      },
+      setShaderUniformsToChannel: function (gl, shaderObject, i)
+      {
+         gl .uniformMatrix4fv (shaderObject .x3d_TextureMatrix [i], false, this .matrixArray);
+      },
+   });
 
-	return X3DTextureTransformNode;
+   return X3DTextureTransformNode;
 });