x_ite 8.7.9 → 8.8.0

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

@@ -62,32 +62,9 @@ function TextureCoordinateGenerator (executionContext)
    this .parameter = new Float32Array (6);
 }
 
-TextureCoordinateGenerator .prototype = Object .assign (Object .create (X3DSingleTextureCoordinateNode .prototype),
+Object .assign (Object .setPrototypeOf (TextureCoordinateGenerator .prototype, X3DSingleTextureCoordinateNode .prototype),
 {
-   constructor: TextureCoordinateGenerator,
-   [Symbol .for ("X_ITE.X3DBaseNode.fieldDefinitions")]: new FieldDefinitionArray ([
-      new X3DFieldDefinition (X3DConstants .inputOutput, "metadata",  new Fields .SFNode ()),
-      new X3DFieldDefinition (X3DConstants .inputOutput, "mapping",   new Fields .SFString ()),
-      new X3DFieldDefinition (X3DConstants .inputOutput, "mode",      new Fields .SFString ("SPHERE")),
-      new X3DFieldDefinition (X3DConstants .inputOutput, "parameter", new Fields .MFFloat ()),
-   ]),
-   getTypeName: function ()
-   {
-      return "TextureCoordinateGenerator";
-   },
-   getComponentName: function ()
-   {
-      return "Texturing";
-   },
-   getContainerField: function ()
-   {
-      return "texCoord";
-   },
-   getSpecificationRange: function ()
-   {
-      return ["3.0", "Infinity"];
-   },
-   initialize: function ()
+   initialize ()
    {
       X3DSingleTextureCoordinateNode .prototype .initialize .call (this);
 
@@ -121,7 +98,7 @@ TextureCoordinateGenerator .prototype = Object .assign (Object .create (X3DSingl
             this .mode = ModeType .SPHERE;
       };
    })(),
-   set_parameter__: function ()
+   set_parameter__ ()
    {
       const length = Math .min (this .parameter .length, this ._parameter .length)
 
@@ -130,23 +107,57 @@ TextureCoordinateGenerator .prototype = Object .assign (Object .create (X3DSingl
 
       this .parameter .fill (0, length);
    },
-   get1Point: function (index, vector)
+   get1Point (index, vector)
    {
       return vector;
    },
-   getPoints: function (array)
+   getPoints (array)
    {
       return array;
    },
-   addPointToChannel: function (index, array)
+   addPointToChannel (index, array)
    {
       array .push (0, 0, 0, 1);
    },
-   setShaderUniforms: function (gl, shaderObject, channel = 0)
+   setShaderUniforms (gl, shaderObject, channel = 0)
    {
       gl .uniform1i  (shaderObject .x3d_TextureCoordinateGeneratorMode [channel],      this .mode);
       gl .uniform1fv (shaderObject .x3d_TextureCoordinateGeneratorParameter [channel], this .parameter);
    },
 });
 
+Object .defineProperties (TextureCoordinateGenerator,
+{
+   typeName:
+   {
+      value: "TextureCoordinateGenerator",
+      enumerable: true,
+   },
+   componentName:
+   {
+      value: "Texturing",
+      enumerable: true,
+   },
+   containerField:
+   {
+      value: "texCoord",
+      enumerable: true,
+   },
+   specificationRange:
+   {
+      value: Object .freeze (["3.0", "Infinity"]),
+      enumerable: true,
+   },
+   fieldDefinitions:
+   {
+      value: new FieldDefinitionArray ([
+         new X3DFieldDefinition (X3DConstants .inputOutput, "metadata",  new Fields .SFNode ()),
+         new X3DFieldDefinition (X3DConstants .inputOutput, "mapping",   new Fields .SFString ()),
+         new X3DFieldDefinition (X3DConstants .inputOutput, "mode",      new Fields .SFString ("SPHERE")),
+         new X3DFieldDefinition (X3DConstants .inputOutput, "parameter", new Fields .MFFloat ()),
+      ]),
+      enumerable: true,
+   },
+});
+
 export default TextureCoordinateGenerator;

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

@@ -66,40 +66,9 @@ function TextureProperties (executionContext)
    }
 }
 
-TextureProperties .prototype = Object .assign (Object .create (X3DNode .prototype),
+Object .assign (Object .setPrototypeOf (TextureProperties .prototype, X3DNode .prototype),
 {
-   constructor: TextureProperties,
-   [Symbol .for ("X_ITE.X3DBaseNode.fieldDefinitions")]: new FieldDefinitionArray ([
-      new X3DFieldDefinition (X3DConstants .inputOutput,    "metadata",            new Fields .SFNode ()),
-      new X3DFieldDefinition (X3DConstants .inputOutput,    "borderColor",         new Fields .SFColorRGBA ()),
-      new X3DFieldDefinition (X3DConstants .inputOutput,    "borderWidth",         new Fields .SFInt32 ()),
-      new X3DFieldDefinition (X3DConstants .inputOutput,    "anisotropicDegree",   new Fields .SFFloat (1)),
-      new X3DFieldDefinition (X3DConstants .initializeOnly, "generateMipMaps",     new Fields .SFBool ()),
-      new X3DFieldDefinition (X3DConstants .inputOutput,    "minificationFilter",  new Fields .SFString ("FASTEST")),
-      new X3DFieldDefinition (X3DConstants .inputOutput,    "magnificationFilter", new Fields .SFString ("FASTEST")),
-      new X3DFieldDefinition (X3DConstants .inputOutput,    "boundaryModeS",       new Fields .SFString ("REPEAT")),
-      new X3DFieldDefinition (X3DConstants .inputOutput,    "boundaryModeT",       new Fields .SFString ("REPEAT")),
-      new X3DFieldDefinition (X3DConstants .inputOutput,    "boundaryModeR",       new Fields .SFString ("REPEAT")),
-      new X3DFieldDefinition (X3DConstants .inputOutput,    "textureCompression",  new Fields .SFString ("FASTEST")),
-      new X3DFieldDefinition (X3DConstants .inputOutput,    "texturePriority",     new Fields .SFFloat ()),
-   ]),
-   getTypeName: function ()
-   {
-      return "TextureProperties";
-   },
-   getComponentName: function ()
-   {
-      return "Texturing";
-   },
-   getContainerField: function ()
-   {
-      return "textureProperties";
-   },
-   getSpecificationRange: function ()
-   {
-      return ["3.0", "Infinity"];
-   },
-   getBorderWidth: function ()
+   getBorderWidth ()
    {
       // https://stackoverflow.com/questions/27760277/webgl-border-color-shader?lq=1
       return Algorithm .clamp (this ._borderWidth .getValue (), 0, 1);
@@ -124,15 +93,15 @@ TextureProperties .prototype = Object .assign (Object .create (X3DNode .prototyp
          return "REPEAT";
       };
    })(),
-   getBoundaryModeS: function ()
+   getBoundaryModeS ()
    {
       return this .getBoundaryMode (this ._boundaryModeS .getValue ());
    },
-   getBoundaryModeT: function ()
+   getBoundaryModeT ()
    {
       return this .getBoundaryMode (this ._boundaryModeT .getValue ());
    },
-   getBoundaryModeR: function ()
+   getBoundaryModeR ()
    {
       return this .getBoundaryMode (this ._boundaryModeR .getValue ());
    },
@@ -212,4 +181,46 @@ TextureProperties .prototype = Object .assign (Object .create (X3DNode .prototyp
    })(),
 });
 
+Object .defineProperties (TextureProperties,
+{
+   typeName:
+   {
+      value: "TextureProperties",
+      enumerable: true,
+   },
+   componentName:
+   {
+      value: "Texturing",
+      enumerable: true,
+   },
+   containerField:
+   {
+      value: "textureProperties",
+      enumerable: true,
+   },
+   specificationRange:
+   {
+      value: Object .freeze (["3.0", "Infinity"]),
+      enumerable: true,
+   },
+   fieldDefinitions:
+   {
+      value: new FieldDefinitionArray ([
+         new X3DFieldDefinition (X3DConstants .inputOutput,    "metadata",            new Fields .SFNode ()),
+         new X3DFieldDefinition (X3DConstants .inputOutput,    "borderColor",         new Fields .SFColorRGBA ()),
+         new X3DFieldDefinition (X3DConstants .inputOutput,    "borderWidth",         new Fields .SFInt32 ()),
+         new X3DFieldDefinition (X3DConstants .inputOutput,    "anisotropicDegree",   new Fields .SFFloat (1)),
+         new X3DFieldDefinition (X3DConstants .initializeOnly, "generateMipMaps",     new Fields .SFBool ()),
+         new X3DFieldDefinition (X3DConstants .inputOutput,    "minificationFilter",  new Fields .SFString ("FASTEST")),
+         new X3DFieldDefinition (X3DConstants .inputOutput,    "magnificationFilter", new Fields .SFString ("FASTEST")),
+         new X3DFieldDefinition (X3DConstants .inputOutput,    "boundaryModeS",       new Fields .SFString ("REPEAT")),
+         new X3DFieldDefinition (X3DConstants .inputOutput,    "boundaryModeT",       new Fields .SFString ("REPEAT")),
+         new X3DFieldDefinition (X3DConstants .inputOutput,    "boundaryModeR",       new Fields .SFString ("REPEAT")),
+         new X3DFieldDefinition (X3DConstants .inputOutput,    "textureCompression",  new Fields .SFString ("FASTEST")),
+         new X3DFieldDefinition (X3DConstants .inputOutput,    "texturePriority",     new Fields .SFFloat ()),
+      ]),
+      enumerable: true,
+   },
+});
+
 export default TextureProperties;

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

@@ -65,34 +65,9 @@ function TextureTransform (executionContext)
    this .matrix = new Matrix4 ();
 }
 
-TextureTransform .prototype = Object .assign (Object .create (X3DSingleTextureTransformNode .prototype),
+Object .assign (Object .setPrototypeOf (TextureTransform .prototype, X3DSingleTextureTransformNode .prototype),
 {
-   constructor: TextureTransform,
-   [Symbol .for ("X_ITE.X3DBaseNode.fieldDefinitions")]: new FieldDefinitionArray ([
-      new X3DFieldDefinition (X3DConstants .inputOutput, "metadata",    new Fields .SFNode ()),
-      new X3DFieldDefinition (X3DConstants .inputOutput, "mapping",     new Fields .SFString ()),
-      new X3DFieldDefinition (X3DConstants .inputOutput, "translation", new Fields .SFVec2f ()),
-      new X3DFieldDefinition (X3DConstants .inputOutput, "rotation",    new Fields .SFFloat ()),
-      new X3DFieldDefinition (X3DConstants .inputOutput, "scale",       new Fields .SFVec2f (1, 1)),
-      new X3DFieldDefinition (X3DConstants .inputOutput, "center",      new Fields .SFVec2f ()),
-   ]),
-   getTypeName: function ()
-   {
-      return "TextureTransform";
-   },
-   getComponentName: function ()
-   {
-      return "Texturing";
-   },
-   getContainerField: function ()
-   {
-      return "textureTransform";
-   },
-   getSpecificationRange: function ()
-   {
-      return ["2.0", "Infinity"];
-   },
-   initialize: function ()
+   initialize ()
    {
       X3DSingleTextureTransformNode .prototype .initialize .call (this);
 
@@ -100,7 +75,7 @@ TextureTransform .prototype = Object .assign (Object .create (X3DSingleTextureTr
 
       this .eventsProcessed ();
    },
-   getMatrix: function ()
+   getMatrix ()
    {
       return this .matrix;
    },
@@ -148,4 +123,40 @@ TextureTransform .prototype = Object .assign (Object .create (X3DSingleTextureTr
    })(),
 });
 
+Object .defineProperties (TextureTransform,
+{
+   typeName:
+   {
+      value: "TextureTransform",
+      enumerable: true,
+   },
+   componentName:
+   {
+      value: "Texturing",
+      enumerable: true,
+   },
+   containerField:
+   {
+      value: "textureTransform",
+      enumerable: true,
+   },
+   specificationRange:
+   {
+      value: Object .freeze (["2.0", "Infinity"]),
+      enumerable: true,
+   },
+   fieldDefinitions:
+   {
+      value: new FieldDefinitionArray ([
+         new X3DFieldDefinition (X3DConstants .inputOutput, "metadata",    new Fields .SFNode ()),
+         new X3DFieldDefinition (X3DConstants .inputOutput, "mapping",     new Fields .SFString ()),
+         new X3DFieldDefinition (X3DConstants .inputOutput, "translation", new Fields .SFVec2f ()),
+         new X3DFieldDefinition (X3DConstants .inputOutput, "rotation",    new Fields .SFFloat ()),
+         new X3DFieldDefinition (X3DConstants .inputOutput, "scale",       new Fields .SFVec2f (1, 1)),
+         new X3DFieldDefinition (X3DConstants .inputOutput, "center",      new Fields .SFVec2f ()),
+      ]),
+      enumerable: true,
+   },
+});
+
 export default TextureTransform;

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

@@ -58,31 +58,44 @@ function X3DSingleTextureCoordinateNode (executionContext)
    this .texCoordArray = X3DGeometryNode .createArray ();
 }
 
-X3DSingleTextureCoordinateNode .prototype = Object .assign (Object .create (X3DTextureCoordinateNode .prototype),
+Object .assign (Object .setPrototypeOf (X3DSingleTextureCoordinateNode .prototype, X3DTextureCoordinateNode .prototype),
 {
-   constructor: X3DSingleTextureCoordinateNode,
-   getCount: function ()
+   getCount ()
    {
       return 1;
    },
-   init: function (multiArray)
+   init (multiArray)
    {
       this .texCoordArray .length = 0;
 
       multiArray .push (this .texCoordArray);
    },
-   addPoint: function (index, multiArray)
+   addPoint (index, multiArray)
    {
       this .addPointToChannel (index, multiArray [0]);
    },
-   getTextureCoordinateMapping: function (textureCoordinateMapping, channel = 0)
+   getTextureCoordinateMapping (textureCoordinateMapping, channel = 0)
    {
       textureCoordinateMapping .set (this ._mapping .getValue () || channel, channel);
    },
-   setShaderUniforms: function (gl, shaderObject, channel = 0)
+   setShaderUniforms (gl, shaderObject, channel = 0)
    {
       gl .uniform1i (shaderObject .x3d_TextureCoordinateGeneratorMode [channel], 0);
    },
 });
 
+Object .defineProperties (X3DSingleTextureCoordinateNode,
+{
+   typeName:
+   {
+      value: "X3DSingleTextureCoordinateNode",
+      enumerable: true,
+   },
+   componentName:
+   {
+      value: "Texturing",
+      enumerable: true,
+   },
+});
+
 export default X3DSingleTextureCoordinateNode;

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

@@ -56,10 +56,9 @@ function X3DSingleTextureNode (executionContext)
    this .addType (X3DConstants .X3DSingleTextureNode);
 }
 
-X3DSingleTextureNode .prototype = Object .assign (Object .create (X3DTextureNode .prototype),
+Object .assign (Object .setPrototypeOf (X3DSingleTextureNode .prototype, X3DTextureNode .prototype),
 {
-   constructor: X3DSingleTextureNode,
-   initialize: function ()
+   initialize ()
    {
       X3DTextureNode .prototype .initialize .call (this);
 
@@ -71,7 +70,7 @@ X3DSingleTextureNode .prototype = Object .assign (Object .create (X3DTextureNode
 
       this .set_textureProperties__ (false);
    },
-   set_textureProperties__: function (update)
+   set_textureProperties__ (update)
    {
       if (this .texturePropertiesNode)
          this .texturePropertiesNode .removeInterest ("updateTextureParameters", this);
@@ -86,11 +85,11 @@ X3DSingleTextureNode .prototype = Object .assign (Object .create (X3DTextureNode
       if (update)
          this .updateTextureParameters ();
    },
-   getCount: function ()
+   getCount ()
    {
       return 1;
    },
-   getTexture: function ()
+   getTexture ()
    {
       return this .texture;
    },
@@ -157,7 +156,7 @@ X3DSingleTextureNode .prototype = Object .assign (Object .create (X3DTextureNode
          }
       };
    })(),
-   updateTextureBits: function (textureBits, channel = 0)
+   updateTextureBits (textureBits, channel = 0)
    {
       const textureType = this .getTextureType () - 1;
 
@@ -174,9 +173,23 @@ X3DSingleTextureNode .prototype = Object .assign (Object .create (X3DTextureNode
 
       return function (options, channel = 0)
       {
-         options .push ("X3D_TEXTURE" + channel + "_" + textureTypes [this .getTextureType ()]);
+         options .push (`X3D_TEXTURE${channel}_${textureTypes [this .getTextureType ()]}`);
       };
    })(),
 });
 
+Object .defineProperties (X3DSingleTextureNode,
+{
+   typeName:
+   {
+      value: "X3DSingleTextureNode",
+      enumerable: true,
+   },
+   componentName:
+   {
+      value: "Texturing",
+      enumerable: true,
+   },
+});
+
 export default X3DSingleTextureNode;

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

@@ -58,29 +58,42 @@ function X3DSingleTextureTransformNode (executionContext)
    this .matrixArray = new Float32Array (Matrix4 .Identity);
 }
 
-X3DSingleTextureTransformNode .prototype = Object .assign (Object .create (X3DTextureTransformNode .prototype),
+Object .assign (Object .setPrototypeOf (X3DSingleTextureTransformNode .prototype, X3DTextureTransformNode .prototype),
 {
-   constructor: X3DSingleTextureTransformNode,
-   getCount: function ()
+   getCount ()
    {
       return 1;
    },
-   setMatrix: function (value)
+   setMatrix (value)
    {
       this .matrixArray .set (value);
    },
-   getTextureTransformMapping: function (textureTransformMapping, channel = 0)
+   getTextureTransformMapping (textureTransformMapping, channel = 0)
    {
       textureTransformMapping .set (this ._mapping .getValue () || channel, channel);
    },
-   setShaderUniforms: function (gl, shaderObject, channel = 0)
+   setShaderUniforms (gl, shaderObject, channel = 0)
    {
       gl .uniformMatrix4fv (shaderObject .x3d_TextureMatrix [channel], false, this .matrixArray);
    },
-   transformPoint: function (texCoord)
+   transformPoint (texCoord)
    {
       return Matrix4 .prototype .multVecMatrix .call (this .matrixArray, texCoord);
    },
 });
 
+Object .defineProperties (X3DSingleTextureTransformNode,
+{
+   typeName:
+   {
+      value: "X3DSingleTextureTransformNode",
+      enumerable: true,
+   },
+   componentName:
+   {
+      value: "Texturing",
+      enumerable: true,
+   },
+});
+
 export default X3DSingleTextureTransformNode;

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

@@ -63,10 +63,9 @@ function X3DTexture2DNode (executionContext)
    this .height = 0;
 }
 
-X3DTexture2DNode .prototype = Object .assign (Object .create (X3DSingleTextureNode .prototype),
+Object .assign (Object .setPrototypeOf (X3DTexture2DNode .prototype, X3DSingleTextureNode .prototype),
 {
-   constructor: X3DTexture2DNode,
-   initialize: function ()
+   initialize ()
    {
       X3DSingleTextureNode .prototype .initialize .call (this);
 
@@ -78,31 +77,31 @@ X3DTexture2DNode .prototype = Object .assign (Object .create (X3DSingleTextureNo
       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 ()
+   getTarget ()
    {
       return this .target;
    },
-   getTextureType: function ()
+   getTextureType ()
    {
       return 2;
    },
-   getTextureTypeString: function ()
+   getTextureTypeString ()
    {
       return "2D";
    },
-   getWidth: function ()
+   getWidth ()
    {
       return this .width;
    },
-   getHeight: function ()
+   getHeight ()
    {
       return this .height;
    },
-   clearTexture: function ()
+   clearTexture ()
    {
       this .setTexture (1, 1, false, defaultData, false);
    },
-   setTexture: function (width, height, transparent, data, flipY)
+   setTexture (width, height, transparent, data, flipY)
    {
       this .width  = width;
       this .height = height;
@@ -120,7 +119,7 @@ X3DTexture2DNode .prototype = Object .assign (Object .create (X3DSingleTextureNo
       this .updateTextureParameters ();
       this .addNodeEvent ();
    },
-   updateTexture: function (data, flipY)
+   updateTexture (data, flipY)
    {
       const gl = this .getBrowser () .getContext ();
 
@@ -134,7 +133,7 @@ X3DTexture2DNode .prototype = Object .assign (Object .create (X3DSingleTextureNo
 
       this .addNodeEvent ();
    },
-   updateTextureParameters: function ()
+   updateTextureParameters ()
    {
       X3DSingleTextureNode .prototype .updateTextureParameters .call (this,
                                                                       this .target,
@@ -146,7 +145,7 @@ X3DTexture2DNode .prototype = Object .assign (Object .create (X3DSingleTextureNo
                                                                       this ._repeatT .getValue (),
                                                                       false);
    },
-   setShaderUniforms: function (gl, shaderObject, renderObject, channel = shaderObject .x3d_Texture [0])
+   setShaderUniforms (gl, shaderObject, renderObject, channel = shaderObject .x3d_Texture [0])
    {
       const textureUnit = this .getBrowser () .getTexture2DUnit ();
 
@@ -156,4 +155,18 @@ X3DTexture2DNode .prototype = Object .assign (Object .create (X3DSingleTextureNo
    },
 });
 
+Object .defineProperties (X3DTexture2DNode,
+{
+   typeName:
+   {
+      value: "X3DTexture2DNode",
+      enumerable: true,
+   },
+   componentName:
+   {
+      value: "Texturing",
+      enumerable: true,
+   },
+});
+
 export default X3DTexture2DNode;

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

@@ -55,9 +55,20 @@ function X3DTextureCoordinateNode (executionContext)
    this .addType (X3DConstants .X3DTextureCoordinateNode);
 }
 
-X3DTextureCoordinateNode .prototype = Object .assign (Object .create (X3DGeometricPropertyNode .prototype),
+Object .setPrototypeOf (X3DTextureCoordinateNode .prototype, X3DGeometricPropertyNode .prototype);
+
+Object .defineProperties (X3DTextureCoordinateNode,
 {
-   constructor: X3DTextureCoordinateNode,
+   typeName:
+   {
+      value: "X3DTextureCoordinateNode",
+      enumerable: true,
+   },
+   componentName:
+   {
+      value: "Texturing",
+      enumerable: true,
+   },
 });
 
 export default X3DTextureCoordinateNode;

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

@@ -60,18 +60,31 @@ function X3DTextureNode (executionContext)
    this ._transparent .setAccessType (X3DConstants .outputOnly);
 }
 
-X3DTextureNode .prototype = Object .assign (Object .create (X3DAppearanceChildNode .prototype),
+Object .assign (Object .setPrototypeOf (X3DTextureNode .prototype, X3DAppearanceChildNode .prototype),
 {
-   constructor: X3DTextureNode,
-   setTransparent: function (value)
+   setTransparent (value)
    {
       if (value !== this ._transparent .getValue ())
          this ._transparent = value;
    },
-   isTransparent: function ()
+   isTransparent ()
    {
       return this ._transparent .getValue ();
    },
 });
 
+Object .defineProperties (X3DTextureNode,
+{
+   typeName:
+   {
+      value: "X3DTextureNode",
+      enumerable: true,
+   },
+   componentName:
+   {
+      value: "Texturing",
+      enumerable: true,
+   },
+});
+
 export default X3DTextureNode;

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

@@ -55,9 +55,20 @@ function X3DTextureTransformNode (executionContext)
    this .addType (X3DConstants .X3DTextureTransformNode);
 }
 
-X3DTextureTransformNode .prototype = Object .assign (Object .create (X3DAppearanceChildNode .prototype),
+Object .setPrototypeOf (X3DTextureTransformNode .prototype, X3DAppearanceChildNode .prototype);
+
+Object .defineProperties (X3DTextureTransformNode,
 {
-   constructor: X3DTextureTransformNode,
+   typeName:
+   {
+      value: "X3DTextureTransformNode",
+      enumerable: true,
+   },
+   componentName:
+   {
+      value: "Texturing",
+      enumerable: true,
+   },
 });
 
 export default X3DTextureTransformNode;