x_ite 8.7.9 → 8.8.0

package/src/x_ite/Browser/Geometry2D/X3DGeometry2DContext.js

@@ -54,33 +54,33 @@ import PrimitiveQuality   from "../Core/PrimitiveQuality.js";
 
 function X3DGeometry2DContext () { }
 
-X3DGeometry2DContext .prototype =
+Object .assign (X3DGeometry2DContext .prototype,
 {
-   initialize: function ()
+   initialize ()
    {
       this .setPrimitiveQuality2D (this .getBrowserOptions () .getPrimitiveQuality ());
    },
-   getArc2DOptions: function ()
+   getArc2DOptions ()
    {
       return getOptionNode .call (this, "getArc2DOptions", Arc2DOptions);
    },
-   getArcClose2DOptions: function ()
+   getArcClose2DOptions ()
    {
       return getOptionNode .call (this, "getArcClose2DOptions", ArcClose2DOptions);
    },
-   getCircle2DOptions: function ()
+   getCircle2DOptions ()
    {
       return getOptionNode .call (this, "getCircle2DOptions", Circle2DOptions);
    },
-   getDisk2DOptions: function ()
+   getDisk2DOptions ()
    {
       return getOptionNode .call (this, "getDisk2DOptions", Disk2DOptions);
    },
-   getRectangle2DOptions: function ()
+   getRectangle2DOptions ()
    {
       return getOptionNode .call (this, "getRectangle2DOptions", Rectangle2DOptions);
    },
-   setPrimitiveQuality2D: function (primitiveQuality)
+   setPrimitiveQuality2D (primitiveQuality)
    {
       const
          arc      = this .getArc2DOptions (),
@@ -116,7 +116,7 @@ X3DGeometry2DContext .prototype =
          }
       }
    },
-};
+});
 
 function getOptionNode (key, OptionNode)
 {

package/src/x_ite/Browser/Geometry3D/BoxOptions.js

@@ -56,26 +56,13 @@ function BoxOptions (executionContext)
    X3DBaseNode .call (this, executionContext);
 }
 
-BoxOptions .prototype = Object .assign (Object .create (X3DBaseNode .prototype),
+Object .assign (Object .setPrototypeOf (BoxOptions .prototype, X3DBaseNode .prototype),
 {
-   constructor: BoxOptions,
-   getTypeName: function ()
-   {
-      return "BoxOptions";
-   },
-   getComponentName: function ()
-   {
-      return "X_ITE";
-   },
-   getContainerField: function ()
-   {
-      return "boxOptions";
-   },
-   initialize: function ()
+   initialize ()
    {
       X3DBaseNode .prototype .initialize .call (this);
    },
-   getGeometry: function ()
+   getGeometry ()
    {
       if (this .geometry)
          return this .geometry;
@@ -124,4 +111,13 @@ BoxOptions .prototype = Object .assign (Object .create (X3DBaseNode .prototype),
    },
 });
 
+Object .defineProperties (BoxOptions,
+{
+   typeName:
+   {
+      value: "BoxOptions",
+      enumerable: true,
+   },
+});
+
 export default BoxOptions;

package/src/x_ite/Browser/Geometry3D/ConeOptions.js

@@ -56,20 +56,14 @@ function ConeOptions (executionContext)
                           "yDimension", new Fields .SFInt32 (1))
 }
 
-ConeOptions .prototype = Object .assign (Object .create (X3DBaseNode .prototype),
+Object .setPrototypeOf (ConeOptions .prototype, X3DBaseNode .prototype);
+
+Object .defineProperties (ConeOptions,
 {
-   constructor: ConeOptions,
-   getTypeName: function ()
-   {
-      return "ConeOptions";
-   },
-   getComponentName: function ()
-   {
-      return "X_ITE";
-   },
-   getContainerField: function ()
+   typeName:
    {
-      return "coneOptions";
+      value: "ConeOptions",
+      enumerable: true,
    },
 });
 

package/src/x_ite/Browser/Geometry3D/CylinderOptions.js

@@ -56,20 +56,14 @@ function CylinderOptions (executionContext)
                           "yDimension", new Fields .SFInt32 (1))
 }
 
-CylinderOptions .prototype = Object .assign (Object .create (X3DBaseNode .prototype),
+Object .setPrototypeOf (CylinderOptions .prototype, X3DBaseNode .prototype);
+
+Object .defineProperties (CylinderOptions,
 {
-   constructor: CylinderOptions,
-   getTypeName: function ()
-   {
-      return "CylinderOptions";
-   },
-   getComponentName: function ()
-   {
-      return "X_ITE";
-   },
-   getContainerField: function ()
+   typeName:
    {
-      return "cylinderOptions";
+      value: "CylinderOptions",
+      enumerable: true,
    },
 });
 

package/src/x_ite/Browser/Geometry3D/IcoSphereOptions.js

@@ -60,35 +60,22 @@ function IcoSphereOptions (executionContext)
                           "order", new Fields .SFInt32 (2))
 }
 
-IcoSphereOptions .prototype = Object .assign (Object .create (X3DBaseNode .prototype),
+Object .assign (Object .setPrototypeOf (IcoSphereOptions .prototype, X3DBaseNode .prototype),
 {
-   constructor: IcoSphereOptions,
-   getTypeName: function ()
-   {
-      return "IcoSphereOptions";
-   },
-   getComponentName: function ()
-   {
-      return "X_ITE";
-   },
-   getContainerField: function ()
-   {
-      return "quadSphereOptions";
-   },
-   initialize: function ()
+   initialize ()
    {
       X3DBaseNode .prototype .initialize .call (this);
 
       this .addInterest ("eventsProcessed", this);
    },
-   getGeometry: function ()
+   getGeometry ()
    {
       if (! this .geometry)
          this .eventsProcessed ();
 
       return this .geometry;
    },
-   eventsProcessed: function ()
+   eventsProcessed ()
    {
       this .geometry            = new IndexedFaceSet (this .getExecutionContext ());
       this .geometry ._texCoord = new TextureCoordinate (this .getExecutionContext ());
@@ -115,4 +102,13 @@ IcoSphereOptions .prototype = Object .assign (Object .create (X3DBaseNode .proto
    },
 });
 
+Object .defineProperties (IcoSphereOptions,
+{
+   typeName:
+   {
+      value: "IcoSphereOptions",
+      enumerable: true,
+   },
+});
+
 export default IcoSphereOptions;

package/src/x_ite/Browser/Geometry3D/QuadSphereOptions.js

@@ -62,35 +62,22 @@ function QuadSphereOptions (executionContext)
                           "yDimension", new Fields .SFInt32 (15))
 }
 
-QuadSphereOptions .prototype = Object .assign (Object .create (X3DBaseNode .prototype),
+Object .assign (Object .setPrototypeOf (QuadSphereOptions .prototype, X3DBaseNode .prototype),
 {
-   constructor: QuadSphereOptions,
-   getTypeName: function ()
-   {
-      return "QuadSphereOptions";
-   },
-   getComponentName: function ()
-   {
-      return "X_ITE";
-   },
-   getContainerField: function ()
-   {
-      return "quadSphereOptions";
-   },
-   initialize: function ()
+   initialize ()
    {
       X3DBaseNode .prototype .initialize .call (this);
 
       this .addInterest ("eventsProcessed", this);
    },
-   getGeometry: function ()
+   getGeometry ()
    {
       if (! this .geometry)
          this .eventsProcessed ();
 
       return this .geometry;
    },
-   createTexCoordIndex: function ()
+   createTexCoordIndex ()
    {
       const
          xDimension    = this ._xDimension .getValue () + 1,
@@ -133,7 +120,7 @@ QuadSphereOptions .prototype = Object .assign (Object .create (X3DBaseNode .prot
          texCoordIndex .push (-1);
       }
    },
-   createTexCoord: function ()
+   createTexCoord ()
    {
       const
          xDimension = this ._xDimension .getValue () + 1,
@@ -174,7 +161,7 @@ QuadSphereOptions .prototype = Object .assign (Object .create (X3DBaseNode .prot
          point .push (new Vector2 (x, 0));
       }
    },
-   createCoordIndex: function ()
+   createCoordIndex ()
    {
       const
          xDimension = this ._xDimension .getValue () + 1,
@@ -237,7 +224,7 @@ QuadSphereOptions .prototype = Object .assign (Object .create (X3DBaseNode .prot
       coordIndex .push (p);
       coordIndex .push (-1);
    },
-   createPoints: function ()
+   createPoints ()
    {
       const
          xDimension = this ._xDimension .getValue () + 1,
@@ -263,7 +250,7 @@ QuadSphereOptions .prototype = Object .assign (Object .create (X3DBaseNode .prot
       // South pole
       point .push (new Vector3 (0, -1, 0));
    },
-   eventsProcessed: function ()
+   eventsProcessed ()
    {
       this .geometry            = new IndexedFaceSet (this .getExecutionContext ());
       this .geometry ._texCoord = new TextureCoordinate (this .getExecutionContext ());
@@ -287,4 +274,13 @@ QuadSphereOptions .prototype = Object .assign (Object .create (X3DBaseNode .prot
    },
 });
 
+Object .defineProperties (QuadSphereOptions,
+{
+   typeName:
+   {
+      value: "QuadSphereOptions",
+      enumerable: true,
+   },
+});
+
 export default QuadSphereOptions;

package/src/x_ite/Browser/Geometry3D/X3DGeometry3DContext.js

@@ -53,29 +53,29 @@ import PrimitiveQuality  from "../Core/PrimitiveQuality.js";
 
 function X3DGeometry3DContext () { }
 
-X3DGeometry3DContext .prototype =
+Object .assign (X3DGeometry3DContext .prototype,
 {
-   initialize: function ()
+   initialize ()
    {
       this .setPrimitiveQuality3D (this .getBrowserOptions () .getPrimitiveQuality ());
    },
-   getBoxOptions: function ()
+   getBoxOptions ()
    {
       return getOptionNode .call (this, "getBoxOptions", BoxOptions);
    },
-   getConeOptions: function ()
+   getConeOptions ()
    {
       return getOptionNode .call (this, "getConeOptions", ConeOptions);
    },
-   getCylinderOptions: function ()
+   getCylinderOptions ()
    {
       return getOptionNode .call (this, "getCylinderOptions", CylinderOptions);
    },
-   getSphereOptions: function ()
+   getSphereOptions ()
    {
       return getOptionNode .call (this, "getSphereOptions", QuadSphereOptions);
    },
-   setPrimitiveQuality3D: function (primitiveQuality)
+   setPrimitiveQuality3D (primitiveQuality)
    {
       const
          cone     = this .getConeOptions (),
@@ -110,7 +110,7 @@ X3DGeometry3DContext .prototype =
          }
       }
    },
-};
+});
 
 function getOptionNode (key, OptionNode)
 {

package/src/x_ite/Browser/Geospatial/Geocentric.js

@@ -49,18 +49,17 @@ import Algorithm from "../../../standard/Math/Algorithm.js";
 
 function Geocentric () { }
 
-Geocentric .prototype =
+Object .assign (Geocentric .prototype,
 {
-   constructor: Geocentric,
-   convert: function (geocentric, result)
+   convert (geocentric, result)
    {
       return result .assign (geocentric);
    },
-   apply: function (geocentric, result)
+   apply (geocentric, result)
    {
       return result .assign (geocentric);
    },
-   slerp: function (source, destination, t)
+   slerp (source, destination, t)
    {
       const
          sourceLength      = source      .magnitude (),
@@ -71,6 +70,6 @@ Geocentric .prototype =
 
       return Algorithm .simpleSlerp (source, destination, t) .multiply (Algorithm .lerp (sourceLength, destinationLength, t));
    },
-};
+});
 
 export default Geocentric;

package/src/x_ite/Browser/Geospatial/Geospatial.js

@@ -73,7 +73,7 @@ const Geospatial =
    GD: GD,
    UTM: UTM,
    GC: GC,
-   getReferenceFrame: function (geoSystem, radians)
+   getReferenceFrame (geoSystem, radians)
    {
       switch (this .getCoordinateSystem (geoSystem))
       {
@@ -98,11 +98,11 @@ const Geospatial =
 
       return new Geodetic (ReferenceEllipsoids .WE, true, radians);
    },
-   getElevationFrame: function (geoSystem, radians)
+   getElevationFrame (geoSystem, radians)
    {
       return new Geodetic (this .getEllipsoid (geoSystem), true, radians);
    },
-   getCoordinateSystem: function (geoSystem)
+   getCoordinateSystem (geoSystem)
    {
       for (const gs of geoSystem)
       {
@@ -114,7 +114,7 @@ const Geospatial =
 
       return GD;
    },
-   getEllipsoid: function (geoSystem)
+   getEllipsoid (geoSystem)
    {
       for (const gs of geoSystem)
       {
@@ -126,7 +126,7 @@ const Geospatial =
 
       return ReferenceEllipsoids .WE;
    },
-   getEllipsoidString: function (geoSystem)
+   getEllipsoidString (geoSystem)
    {
       for (const gs of geoSystem)
       {
@@ -138,7 +138,7 @@ const Geospatial =
 
       return "WE";
    },
-   isStandardOrder: function (geoSystem)
+   isStandardOrder (geoSystem)
    {
       switch (this .getCoordinateSystem (geoSystem))
       {
@@ -158,7 +158,7 @@ const Geospatial =
 
       return this .getLatitudeFirst (geoSystem);
    },
-   getLatitudeFirst: function (geoSystem)
+   getLatitudeFirst (geoSystem)
    {
       for (const gs of geoSystem)
       {
@@ -168,7 +168,7 @@ const Geospatial =
 
       return true;
    },
-   getNorthingFirst: function (geoSystem)
+   getNorthingFirst (geoSystem)
    {
       for (const gs of geoSystem)
       {
@@ -178,7 +178,7 @@ const Geospatial =
 
       return true;
    },
-   getZone: function (geoSystem)
+   getZone (geoSystem)
    {
       for (const gs of geoSystem)
       {
@@ -190,7 +190,7 @@ const Geospatial =
 
       return 1;
    },
-   getNorthernHemisphere: function (geoSystem)
+   getNorthernHemisphere (geoSystem)
    {
       for (const gs of geoSystem)
       {

package/src/x_ite/Browser/Grouping/X3DGroupingContext.js

@@ -53,9 +53,9 @@ const _bboxShape = Symbol ();
 
 function X3DGroupingContext () { }
 
-X3DGroupingContext .prototype =
+Object .assign (X3DGroupingContext .prototype,
 {
-   getBBoxNode: function ()
+   getBBoxNode ()
    {
       const
          bboxShape      = new Shape (this .getPrivateScene ()),
@@ -79,6 +79,6 @@ X3DGroupingContext .prototype =
 
       return bboxShape;
    },
-};
+});
 
 export default X3DGroupingContext;

package/src/x_ite/Browser/Interpolation/CatmullRomSplineInterpolator.js

@@ -54,9 +54,8 @@ function CatmullRomSplineInterpolator ()
    this .T1 = [ ];
 }
 
-CatmullRomSplineInterpolator .prototype =
+Object .assign (CatmullRomSplineInterpolator .prototype,
 {
-   constructor: CatmullRomSplineInterpolator,
    generate: (function ()
    {
       const
@@ -182,6 +181,6 @@ CatmullRomSplineInterpolator .prototype =
                            this .T1 [index1]);
       };
    })(),
-};
+});
 
 export default CatmullRomSplineInterpolator;

package/src/x_ite/Browser/Interpolation/CatmullRomSplineInterpolator1.js

@@ -52,34 +52,33 @@ function CatmullRomSplineInterpolator1 ()
    CatmullRomSplineInterpolator .call (this);
 }
 
-CatmullRomSplineInterpolator1 .prototype = Object .assign (Object .create (CatmullRomSplineInterpolator .prototype),
+Object .assign (Object .setPrototypeOf (CatmullRomSplineInterpolator1 .prototype, CatmullRomSplineInterpolator .prototype),
 {
-   constructor: CatmullRomSplineInterpolator1,
-   create: function ()
+   create ()
    {
       return 0;
    },
-   copy: function (value)
+   copy (value)
    {
       return value;
    },
-   subtract: function (lhs, rhs)
+   subtract (lhs, rhs)
    {
       return lhs - rhs;
    },
-   multiply: function (lhs, rhs)
+   multiply (lhs, rhs)
    {
       return lhs * rhs;
    },
-   divide: function (lhs, rhs)
+   divide (lhs, rhs)
    {
       return lhs / rhs;
    },
-   magnitude: function (value)
+   magnitude (value)
    {
       return Math .abs (value);
    },
-   dot: function (SH, C0, C1, C2, C3)
+   dot (SH, C0, C1, C2, C3)
    {
       return C0 * SH [0] + C1 * SH [1] + C2 * SH [2] + C3 * SH [3];
    },

package/src/x_ite/Browser/Interpolation/CatmullRomSplineInterpolatorTemplate.js

@@ -55,30 +55,29 @@ function CatmullRomSplineInterpolatorTemplate (Type)
       this .T1 = [ ];
    }
 
-   CatmullRomSplineInterpolatorInstance .prototype = Object .assign (Object .create (CatmullRomSplineInterpolator .prototype),
+   Object .assign (Object .setPrototypeOf (CatmullRomSplineInterpolatorInstance .prototype, CatmullRomSplineInterpolator .prototype),
    {
-      constructor: CatmullRomSplineInterpolatorInstance,
-      create: function ()
+      create ()
       {
          return Type .Zero .copy ();
       },
-      copy: function (value)
+      copy (value)
       {
          return value .copy ();
       },
-      subtract: function (lhs, rhs)
+      subtract (lhs, rhs)
       {
          return lhs .copy () .subtract (rhs);
       },
-      multiply: function (lhs, rhs)
+      multiply (lhs, rhs)
       {
          return lhs .copy () .multiply (rhs);
       },
-      divide: function (lhs, rhs)
+      divide (lhs, rhs)
       {
          return lhs .copy () .divide (rhs);
       },
-      magnitude: function (value)
+      magnitude (value)
       {
          return value .magnitude ();
       },

package/src/x_ite/Browser/Interpolation/SquatInterpolator.js

@@ -52,10 +52,9 @@ function SquatInterpolator ()
    this .s = [ ];
 }
 
-SquatInterpolator .prototype =
+Object .assign (SquatInterpolator .prototype,
 {
-   constructor: SquatInterpolator,
-   generate: function (closed, key, keyValue)
+   generate (closed, key, keyValue)
    {
       const s = this .s;
 
@@ -108,6 +107,6 @@ SquatInterpolator .prototype =
                                                                         keyValue [index1] .getValue (), weight);
       };
    })(),
-};
+});
 
 export default SquatInterpolator;

package/src/x_ite/Browser/KeyDeviceSensor/X3DKeyDeviceSensorContext.js

@@ -57,41 +57,41 @@ function X3DKeyDeviceSensorContext ()
    this [_keyDeviceSensorNodes] = new Set ();
 }
 
-X3DKeyDeviceSensorContext .prototype =
+Object .assign (X3DKeyDeviceSensorContext .prototype,
 {
-   initialize: function ()
+   initialize ()
    {
       const element = this .getElement ();
 
       element .on ("keydown.X3DKeyDeviceSensorContext", this [_keydown] .bind (this));
       element .on ("keyup.X3DKeyDeviceSensorContext",   this [_keyup]   .bind (this));
    },
-   addKeyDeviceSensorNode: function (keyDeviceSensorNode)
+   addKeyDeviceSensorNode (keyDeviceSensorNode)
    {
       this [_keyDeviceSensorNodes] .add (keyDeviceSensorNode);
    },
-   removeKeyDeviceSensorNode: function (keyDeviceSensorNode)
+   removeKeyDeviceSensorNode (keyDeviceSensorNode)
    {
       this [_keyDeviceSensorNodes] .delete (keyDeviceSensorNode);
    },
-   getKeyDeviceSensorNodes: function ()
+   getKeyDeviceSensorNodes ()
    {
       return this [_keyDeviceSensorNodes];
    },
-   [_keydown]: function (event)
+   [_keydown] (event)
    {
       //console .log (event .keyCode);
 
       for (const keyDeviceSensorNode of this [_keyDeviceSensorNodes])
          keyDeviceSensorNode .keydown (event);
    },
-   [_keyup]: function (event)
+   [_keyup] (event)
    {
       //console .log (event .which);
 
       for (const keyDeviceSensorNode of this [_keyDeviceSensorNodes])
          keyDeviceSensorNode .keyup (event);
    },
-};
+});
 
 export default X3DKeyDeviceSensorContext;

package/src/x_ite/Browser/Layering/X3DLayeringContext.js

@@ -54,17 +54,17 @@ function X3DLayeringContext ()
    this [_defaultViewport] = new Viewport (this .getPrivateScene ());
 }
 
-X3DLayeringContext .prototype =
+Object .assign (X3DLayeringContext .prototype,
 {
-   initialize: function ()
+   initialize ()
    {
       this [_defaultViewport] .setPrivate (true);
       this [_defaultViewport] .setup ();
    },
-   getDefaultViewport: function ()
+   getDefaultViewport ()
    {
       return this [_defaultViewport];
    },
-};
+});
 
 export default X3DLayeringContext;