x_ite 8.7.8 → 8.8.0

package/src/x_ite/Components/Texturing3D/TextureCoordinate4D.js

@@ -59,31 +59,9 @@ function TextureCoordinate4D (executionContext)
    this .addType (X3DConstants .TextureCoordinate4D);
 }
 
-TextureCoordinate4D .prototype = Object .assign (Object .create (X3DSingleTextureCoordinateNode .prototype),
+Object .assign (Object .setPrototypeOf (TextureCoordinate4D .prototype, X3DSingleTextureCoordinateNode .prototype),
 {
-   constructor: TextureCoordinate4D,
-   [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, "point",    new Fields .MFVec4f ()),
-   ]),
-   getTypeName: function ()
-   {
-      return "TextureCoordinate4D";
-   },
-   getComponentName: function ()
-   {
-      return "Texturing3D";
-   },
-   getContainerField: function ()
-   {
-      return "texCoord";
-   },
-   getSpecificationRange: function ()
-   {
-      return ["3.1", "Infinity"];
-   },
-   initialize: function ()
+   initialize ()
    {
       X3DSingleTextureCoordinateNode .prototype .initialize .call (this);
 
@@ -91,20 +69,20 @@ TextureCoordinate4D .prototype = Object .assign (Object .create (X3DSingleTextur
 
       this .set_point__ ();
    },
-   set_point__: function ()
+   set_point__ ()
    {
       this .point  = this ._point .getValue ();
       this .length = this ._point .length;
    },
-   isEmpty: function ()
+   isEmpty ()
    {
       return this .length === 0;
    },
-   getSize: function ()
+   getSize ()
    {
       return this .length;
    },
-   get1Point: function (index, vector)
+   get1Point (index, vector)
    {
       if (index >= 0 && index < this .length)
       {
@@ -128,7 +106,7 @@ TextureCoordinate4D .prototype = Object .assign (Object .create (X3DSingleTextur
          return vector .set (0, 0, 0, 1);
       }
    },
-   getPoints: function (array)
+   getPoints (array)
    {
       const
          point  = this .point,
@@ -139,7 +117,7 @@ TextureCoordinate4D .prototype = Object .assign (Object .create (X3DSingleTextur
 
       return array;
    },
-   addPointToChannel: function (index, array)
+   addPointToChannel (index, array)
    {
       if (index >= 0 && index < this .length)
       {
@@ -165,4 +143,37 @@ TextureCoordinate4D .prototype = Object .assign (Object .create (X3DSingleTextur
    },
 });
 
+Object .defineProperties (TextureCoordinate4D,
+{
+   typeName:
+   {
+      value: "TextureCoordinate4D",
+      enumerable: true,
+   },
+   componentName:
+   {
+      value: "Texturing3D",
+      enumerable: true,
+   },
+   containerField:
+   {
+      value: "texCoord",
+      enumerable: true,
+   },
+   specificationRange:
+   {
+      value: Object .freeze (["3.1", "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, "point",    new Fields .MFVec4f ()),
+      ]),
+      enumerable: true,
+   },
+});
+
 export default TextureCoordinate4D;

package/src/x_ite/Components/Texturing3D/TextureTransform3D.js

@@ -63,34 +63,9 @@ function TextureTransform3D (executionContext)
    this .matrix = new Matrix4 ();
 }
 
-TextureTransform3D .prototype = Object .assign (Object .create (X3DSingleTextureTransformNode .prototype),
+Object .assign (Object .setPrototypeOf (TextureTransform3D .prototype, X3DSingleTextureTransformNode .prototype),
 {
-   constructor: TextureTransform3D,
-   [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 .SFVec3f ()),
-      new X3DFieldDefinition (X3DConstants .inputOutput, "rotation",    new Fields .SFRotation ()),
-      new X3DFieldDefinition (X3DConstants .inputOutput, "scale",       new Fields .SFVec3f (1, 1, 1)),
-      new X3DFieldDefinition (X3DConstants .inputOutput, "center",      new Fields .SFVec3f ()),
-   ]),
-   getTypeName: function ()
-   {
-      return "TextureTransform3D";
-   },
-   getComponentName: function ()
-   {
-      return "Texturing3D";
-   },
-   getContainerField: function ()
-   {
-      return "textureTransform";
-   },
-   getSpecificationRange: function ()
-   {
-      return ["3.1", "Infinity"];
-   },
-   initialize: function ()
+   initialize ()
    {
       X3DSingleTextureTransformNode .prototype .initialize .call (this);
 
@@ -98,7 +73,7 @@ TextureTransform3D .prototype = Object .assign (Object .create (X3DSingleTexture
 
       this .eventsProcessed ();
    },
-   getMatrix: function ()
+   getMatrix ()
    {
       return this .matrix;
    },
@@ -137,4 +112,40 @@ TextureTransform3D .prototype = Object .assign (Object .create (X3DSingleTexture
    })(),
 });
 
+Object .defineProperties (TextureTransform3D,
+{
+   typeName:
+   {
+      value: "TextureTransform3D",
+      enumerable: true,
+   },
+   componentName:
+   {
+      value: "Texturing3D",
+      enumerable: true,
+   },
+   containerField:
+   {
+      value: "textureTransform",
+      enumerable: true,
+   },
+   specificationRange:
+   {
+      value: Object .freeze (["3.1", "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 .SFVec3f ()),
+         new X3DFieldDefinition (X3DConstants .inputOutput, "rotation",    new Fields .SFRotation ()),
+         new X3DFieldDefinition (X3DConstants .inputOutput, "scale",       new Fields .SFVec3f (1, 1, 1)),
+         new X3DFieldDefinition (X3DConstants .inputOutput, "center",      new Fields .SFVec3f ()),
+      ]),
+      enumerable: true,
+   },
+});
+
 export default TextureTransform3D;

package/src/x_ite/Components/Texturing3D/TextureTransformMatrix3D.js

@@ -58,45 +58,56 @@ function TextureTransformMatrix3D (executionContext)
    this .addType (X3DConstants .TextureTransformMatrix3D);
 }
 
-TextureTransformMatrix3D .prototype = Object .assign (Object .create (X3DSingleTextureTransformNode .prototype),
+Object .assign (Object .setPrototypeOf (TextureTransformMatrix3D .prototype, X3DSingleTextureTransformNode .prototype),
 {
-   constructor: TextureTransformMatrix3D,
-   [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, "matrix",   new Fields .SFMatrix4f ()),
-   ]),
-   getTypeName: function ()
+   initialize ()
    {
-      return "TextureTransformMatrix3D";
+      X3DSingleTextureTransformNode .prototype .initialize .call (this);
+
+      this .addInterest ("eventsProcessed", this);
+
+      this .eventsProcessed ();
    },
-   getComponentName: function ()
+   getMatrix ()
    {
-      return "Texturing3D";
+      return this ._matrix .getValue ();
    },
-   getContainerField: function ()
+   eventsProcessed ()
    {
-      return "textureTransform";
+      this .setMatrix (this ._matrix .getValue ());
    },
-   getSpecificationRange: function ()
+});
+
+Object .defineProperties (TextureTransformMatrix3D,
+{
+   typeName:
    {
-      return ["3.1", "Infinity"];
+      value: "TextureTransformMatrix3D",
+      enumerable: true,
    },
-   initialize: function ()
+   componentName:
    {
-      X3DSingleTextureTransformNode .prototype .initialize .call (this);
-
-      this .addInterest ("eventsProcessed", this);
-
-      this .eventsProcessed ();
+      value: "Texturing3D",
+      enumerable: true,
    },
-   getMatrix: function ()
+   containerField:
    {
-      return this ._matrix .getValue ();
+      value: "textureTransform",
+      enumerable: true,
    },
-   eventsProcessed: function ()
+   specificationRange:
    {
-      this .setMatrix (this ._matrix .getValue ());
+      value: Object .freeze (["3.1", "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, "matrix",   new Fields .SFMatrix4f ()),
+      ]),
+      enumerable: true,
    },
 });
 

package/src/x_ite/Components/Texturing3D/X3DTexture3DNode.js

@@ -65,10 +65,9 @@ function X3DTexture3DNode (executionContext)
    this .data   = null;
 }
 
-X3DTexture3DNode .prototype = Object .assign (Object .create (X3DSingleTextureNode .prototype),
+Object .assign (Object .setPrototypeOf (X3DTexture3DNode .prototype, X3DSingleTextureNode .prototype),
 {
-   constructor: X3DTexture3DNode,
-   initialize: function ()
+   initialize ()
    {
       X3DSingleTextureNode .prototype .initialize .call (this);
 
@@ -84,31 +83,31 @@ X3DTexture3DNode .prototype = Object .assign (Object .create (X3DSingleTextureNo
       gl .bindTexture (gl .TEXTURE_3D, this .getTexture ());
       gl .texImage3D  (gl .TEXTURE_3D, 0, gl .RGBA, 1, 1, 1, 0, gl .RGBA, gl .UNSIGNED_BYTE, defaultData);
    },
-   getTarget: function ()
+   getTarget ()
    {
       return this .target;
    },
-   getTextureType: function ()
+   getTextureType ()
    {
       return 3;
    },
-   getTextureTypeString: function ()
+   getTextureTypeString ()
    {
       return "3D";
    },
-   getWidth: function ()
+   getWidth ()
    {
       return this .width;
    },
-   getHeight: function ()
+   getHeight ()
    {
       return this .height;
    },
-   getDepth: function ()
+   getDepth ()
    {
       return this .depth;
    },
-   clearTexture: function ()
+   clearTexture ()
    {
       const gl = this .getBrowser () .getContext ();
 
@@ -116,7 +115,7 @@ X3DTexture3DNode .prototype = Object .assign (Object .create (X3DSingleTextureNo
 
       this .data = null;
    },
-   setTexture: function (width, height, depth, transparent, format, data)
+   setTexture (width, height, depth, transparent, format, data)
    {
       this .width  = width;
       this .height = height;
@@ -135,7 +134,7 @@ X3DTexture3DNode .prototype = Object .assign (Object .create (X3DSingleTextureNo
       this .updateTextureParameters ();
       this .addNodeEvent ();
    },
-   updateTextureParameters: function ()
+   updateTextureParameters ()
    {
       X3DSingleTextureNode .prototype .updateTextureParameters .call (this,
                                                                       this .target,
@@ -147,7 +146,7 @@ X3DTexture3DNode .prototype = Object .assign (Object .create (X3DSingleTextureNo
                                                                       this ._repeatT .getValue (),
                                                                       this ._repeatR .getValue ());
    },
-   setShaderUniforms: function (gl, shaderObject, renderObject, channel = shaderObject .x3d_Texture [0])
+   setShaderUniforms (gl, shaderObject, renderObject, channel = shaderObject .x3d_Texture [0])
    {
       const textureUnit = this .getBrowser () .getTexture3DUnit ();
 
@@ -157,4 +156,18 @@ X3DTexture3DNode .prototype = Object .assign (Object .create (X3DSingleTextureNo
    },
 });
 
+Object .defineProperties (X3DTexture3DNode,
+{
+   typeName:
+   {
+      value: "X3DTexture3DNode",
+      enumerable: true,
+   },
+   componentName:
+   {
+      value: "Texturing3D",
+      enumerable: true,
+   },
+});
+
 export default X3DTexture3DNode;

package/src/x_ite/Components/Time/TimeSensor.js

@@ -70,44 +70,10 @@ function TimeSensor (executionContext)
    this .scale    = 1;
 }
 
-TimeSensor .prototype = Object .assign (Object .create (X3DSensorNode .prototype),
+Object .assign (Object .setPrototypeOf (TimeSensor .prototype, X3DSensorNode .prototype),
    X3DTimeDependentNode .prototype,
 {
-   constructor: TimeSensor,
-   [Symbol .for ("X_ITE.X3DBaseNode.fieldDefinitions")]: new FieldDefinitionArray ([
-      new X3DFieldDefinition (X3DConstants .inputOutput, "metadata",         new Fields .SFNode ()),
-      new X3DFieldDefinition (X3DConstants .inputOutput, "description",      new Fields .SFString ()),
-      new X3DFieldDefinition (X3DConstants .inputOutput, "enabled",          new Fields .SFBool (true)),
-      new X3DFieldDefinition (X3DConstants .inputOutput, "cycleInterval",    new Fields .SFTime (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,  "fraction_changed", new Fields .SFFloat ()),
-      new X3DFieldDefinition (X3DConstants .outputOnly,  "time",             new Fields .SFTime ()),
-   ]),
-   getTypeName: function ()
-   {
-      return "TimeSensor";
-   },
-   getComponentName: function ()
-   {
-      return "Time";
-   },
-   getContainerField: function ()
-   {
-      return "children";
-   },
-   getSpecificationRange: function ()
-   {
-      return ["2.0", "Infinity"];
-   },
-   initialize: function ()
+   initialize ()
    {
       X3DSensorNode        .prototype .initialize .call (this);
       X3DTimeDependentNode .prototype .initialize .call (this);
@@ -115,7 +81,7 @@ TimeSensor .prototype = Object .assign (Object .create (X3DSensorNode .prototype
       this ._cycleInterval .addInterest ("set_cycleInterval__", this);
       this ._range         .addInterest ("set_range__",         this);
    },
-   setRange: function (currentFraction, firstFraction, lastFraction)
+   setRange (currentFraction, firstFraction, lastFraction)
    {
       const
          currentTime   = this .getBrowser () .getCurrentTime (),
@@ -129,12 +95,12 @@ TimeSensor .prototype = Object .assign (Object .create (X3DSensorNode .prototype
       this .fraction = Algorithm .fract ((currentFraction >= 1 ? 0 : currentFraction) + (this .interval ? (currentTime - startTime) / this .interval : 0));
       this .cycle    = currentTime - (this .fraction -  this .first) * cycleInterval;
    },
-   set_cycleInterval__: function ()
+   set_cycleInterval__ ()
    {
       if (this ._isActive .getValue ())
          this .setRange (this .fraction, this ._range [1], this ._range [2]);
    },
-   set_range__: function ()
+   set_range__ ()
    {
       if (this ._isActive .getValue ())
       {
@@ -144,7 +110,7 @@ TimeSensor .prototype = Object .assign (Object .create (X3DSensorNode .prototype
             this .set_fraction (this .getBrowser () .getCurrentTime ());
       }
    },
-   set_start: function ()
+   set_start ()
    {
       this .setRange (this ._range [0], this ._range [1], this ._range [2]);
 
@@ -154,7 +120,7 @@ TimeSensor .prototype = Object .assign (Object .create (X3DSensorNode .prototype
          this ._time             = this .getBrowser () .getCurrentTime ();
       }
    },
-   set_resume: function (pauseInterval)
+   set_resume (pauseInterval)
    {
       const
          currentTime   = this .getBrowser () .getCurrentTime (),
@@ -162,11 +128,11 @@ TimeSensor .prototype = Object .assign (Object .create (X3DSensorNode .prototype
 
       this .setRange (this .interval ? Algorithm .fract (this .fraction - (currentTime - startTime) / this .interval) : 0, this ._range [1], this ._range [2]);
    },
-   set_fraction: function (time)
+   set_fraction (time)
    {
       this ._fraction_changed = this .fraction = this .first + (this .interval ? Algorithm .fract ((time - this .cycle) / this .interval) : 0) * this .scale;
    },
-   set_time: function ()
+   set_time ()
    {
       // The event order below is very important.
 
@@ -201,11 +167,56 @@ TimeSensor .prototype = Object .assign (Object .create (X3DSensorNode .prototype
 
       this ._time = time;
    },
-   dispose: function ()
+   dispose ()
    {
       X3DTimeDependentNode .prototype .dispose .call (this);
       X3DSensorNode        .prototype .dispose .call (this);
    },
 });
 
+Object .defineProperties (TimeSensor,
+{
+   typeName:
+   {
+      value: "TimeSensor",
+      enumerable: true,
+   },
+   componentName:
+   {
+      value: "Time",
+      enumerable: true,
+   },
+   containerField:
+   {
+      value: "children",
+      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, "description",      new Fields .SFString ()),
+         new X3DFieldDefinition (X3DConstants .inputOutput, "enabled",          new Fields .SFBool (true)),
+         new X3DFieldDefinition (X3DConstants .inputOutput, "cycleInterval",    new Fields .SFTime (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,  "fraction_changed", new Fields .SFFloat ()),
+         new X3DFieldDefinition (X3DConstants .outputOnly,  "time",             new Fields .SFTime ()),
+      ]),
+      enumerable: true,
+   },
+});
+
 export default TimeSensor;