x_ite 8.7.8 → 8.8.0

package/src/x_ite/Components/Followers/TexCoordDamper2D.js

@@ -63,41 +63,52 @@ function TexCoordDamper2D (executionContext)
    this .addType (X3DConstants .TexCoordDamper2D);
 }
 
-TexCoordDamper2D .prototype = Object .assign (Object .create (X3DDamperNode .prototype),
+Object .assign (Object .setPrototypeOf (TexCoordDamper2D .prototype, X3DDamperNode .prototype),
    X3DArrayFollowerObject .prototype,
 {
-   constructor: TexCoordDamper2D,
-   [Symbol .for ("X_ITE.X3DBaseNode.fieldDefinitions")]: new FieldDefinitionArray ([
-      new X3DFieldDefinition (X3DConstants .inputOutput,    "metadata",           new Fields .SFNode ()),
-      new X3DFieldDefinition (X3DConstants .inputOnly,      "set_value",          new Fields .MFVec2f ()),
-      new X3DFieldDefinition (X3DConstants .inputOnly,      "set_destination",    new Fields .MFVec2f ()),
-      new X3DFieldDefinition (X3DConstants .initializeOnly, "initialValue",       new Fields .MFVec2f ()),
-      new X3DFieldDefinition (X3DConstants .initializeOnly, "initialDestination", new Fields .MFVec2f ()),
-      new X3DFieldDefinition (X3DConstants .initializeOnly, "order",              new Fields .SFInt32 (3)),
-      new X3DFieldDefinition (X3DConstants .inputOutput,    "tau",                new Fields .SFTime (0.3)),
-      new X3DFieldDefinition (X3DConstants .inputOutput,    "tolerance",          new Fields .SFFloat (-1)),
-      new X3DFieldDefinition (X3DConstants .outputOnly,     "isActive",           new Fields .SFBool ()),
-      new X3DFieldDefinition (X3DConstants .outputOnly,     "value_changed",      new Fields .MFVec2f ()),
-   ]),
-   getTypeName: function ()
+   getVector ()
    {
-      return "TexCoordDamper2D";
+      return new Vector2 (0, 0, 0);
    },
-   getComponentName: function ()
+});
+
+Object .defineProperties (TexCoordDamper2D,
+{
+   typeName:
    {
-      return "Followers";
+      value: "TexCoordDamper2D",
+      enumerable: true,
    },
-   getContainerField: function ()
+   componentName:
    {
-      return "children";
+      value: "Followers",
+      enumerable: true,
    },
-   getSpecificationRange: function ()
+   containerField:
    {
-      return ["3.2", "Infinity"];
+      value: "children",
+      enumerable: true,
    },
-   getVector: function ()
+   specificationRange:
    {
-      return new Vector2 (0, 0, 0);
+      value: Object .freeze (["3.2", "Infinity"]),
+      enumerable: true,
+   },
+   fieldDefinitions:
+   {
+      value: new FieldDefinitionArray ([
+         new X3DFieldDefinition (X3DConstants .inputOutput,    "metadata",           new Fields .SFNode ()),
+         new X3DFieldDefinition (X3DConstants .inputOnly,      "set_value",          new Fields .MFVec2f ()),
+         new X3DFieldDefinition (X3DConstants .inputOnly,      "set_destination",    new Fields .MFVec2f ()),
+         new X3DFieldDefinition (X3DConstants .initializeOnly, "initialValue",       new Fields .MFVec2f ()),
+         new X3DFieldDefinition (X3DConstants .initializeOnly, "initialDestination", new Fields .MFVec2f ()),
+         new X3DFieldDefinition (X3DConstants .initializeOnly, "order",              new Fields .SFInt32 (3)),
+         new X3DFieldDefinition (X3DConstants .inputOutput,    "tau",                new Fields .SFTime (0.3)),
+         new X3DFieldDefinition (X3DConstants .inputOutput,    "tolerance",          new Fields .SFFloat (-1)),
+         new X3DFieldDefinition (X3DConstants .outputOnly,     "isActive",           new Fields .SFBool ()),
+         new X3DFieldDefinition (X3DConstants .outputOnly,     "value_changed",      new Fields .MFVec2f ()),
+      ]),
+      enumerable: true,
    },
 });
 

package/src/x_ite/Components/Followers/X3DChaserNode.js

@@ -63,10 +63,9 @@ function X3DChaserNode (executionContext)
    this .deltaOut = this .getVector ();
 }
 
-X3DChaserNode .prototype = Object .assign (Object .create (X3DFollowerNode .prototype),
+Object .assign (Object .setPrototypeOf (X3DChaserNode .prototype, X3DFollowerNode .prototype),
 {
-   constructor: X3DChaserNode,
-   initialize: function ()
+   initialize ()
    {
       X3DFollowerNode .prototype .initialize .call (this);
 
@@ -98,27 +97,27 @@ X3DChaserNode .prototype = Object .assign (Object .create (X3DFollowerNode .prot
       else
          this .set_active (true);
    },
-   getNumBuffers: function ()
+   getNumBuffers ()
    {
       return 60;
    },
-   getTolerance: function ()
+   getTolerance ()
    {
       return 1e-8;
    },
-   getArray: function ()
+   getArray ()
    {
       return this .getVector ();
    },
-   setPreviousValue: function (value)
+   setPreviousValue (value)
    {
       this .previousValue .assign (value);
    },
-   step: function (value1, value2, t)
+   step (value1, value2, t)
    {
       this .output .add (this .deltaOut .assign (value1) .subtract (value2) .multiply (t));
    },
-   stepResponse: function (t)
+   stepResponse (t)
    {
       if (t <= 0)
          return 0;
@@ -130,7 +129,7 @@ X3DChaserNode .prototype = Object .assign (Object .create (X3DFollowerNode .prot
 
       return 0.5 - 0.5 * Math .cos ((t / duration) * Math .PI);
    },
-   set_value__: function ()
+   set_value__ ()
    {
       if (! this ._isActive .getValue ())
          this .bufferEndTime = this .getBrowser () .getCurrentTime ();
@@ -147,7 +146,7 @@ X3DChaserNode .prototype = Object .assign (Object .create (X3DFollowerNode .prot
 
       this .set_active (true);
    },
-   set_destination__: function ()
+   set_destination__ ()
    {
       this .setDestination (this .getDestination ());
 
@@ -156,11 +155,11 @@ X3DChaserNode .prototype = Object .assign (Object .create (X3DFollowerNode .prot
 
       this .set_active (true);
    },
-   set_duration__: function ()
+   set_duration__ ()
    {
       this .stepTime = this ._duration .getValue () / this .getNumBuffers ();
    },
-   prepareEvents: function ()
+   prepareEvents ()
    {
       var
          buffer     = this .getBuffer (),
@@ -181,7 +180,7 @@ X3DChaserNode .prototype = Object .assign (Object .create (X3DFollowerNode .prot
       if (this .equals (this .output, this .destination, this .getTolerance ()))
          this .set_active (false);
    },
-   updateBuffer: function ()
+   updateBuffer ()
    {
       var
          buffer     = this .getBuffer (),
@@ -225,4 +224,18 @@ X3DChaserNode .prototype = Object .assign (Object .create (X3DFollowerNode .prot
    },
 });
 
+Object .defineProperties (X3DChaserNode,
+{
+   typeName:
+   {
+      value: "X3DChaserNode",
+      enumerable: true,
+   },
+   componentName:
+   {
+      value: "Followers",
+      enumerable: true,
+   },
+});
+
 export default X3DChaserNode;

package/src/x_ite/Components/Followers/X3DDamperNode.js

@@ -56,10 +56,9 @@ function X3DDamperNode (executionContext)
    this .addType (X3DConstants .X3DDamperNode);
 }
 
-X3DDamperNode .prototype = Object .assign (Object .create (X3DFollowerNode .prototype),
+Object .assign (Object .setPrototypeOf (X3DDamperNode .prototype, X3DFollowerNode .prototype),
 {
-   constructor: X3DDamperNode,
-   initialize: function ()
+   initialize ()
    {
       X3DFollowerNode .prototype .initialize .call (this);
 
@@ -83,18 +82,18 @@ X3DDamperNode .prototype = Object .assign (Object .create (X3DFollowerNode .prot
       else
          this .set_active (true);
    },
-   getOrder: function ()
+   getOrder ()
    {
       return Algorithm .clamp (this ._order .getValue (), 0, 5);
    },
-   getTolerance: function ()
+   getTolerance ()
    {
       if (this ._tolerance .getValue () < 0)
          return 1e-4;
 
       return this ._tolerance .getValue ();
    },
-   prepareEvents: function ()
+   prepareEvents ()
    {
       var
          buffer = this .getBuffer (),
@@ -128,7 +127,7 @@ X3DDamperNode .prototype = Object .assign (Object .create (X3DFollowerNode .prot
 
       this .set_active (false);
    },
-   set_value__: function ()
+   set_value__ ()
    {
       var
          buffer = this .getBuffer (),
@@ -141,13 +140,13 @@ X3DDamperNode .prototype = Object .assign (Object .create (X3DFollowerNode .prot
 
       this .set_active (true);
    },
-   set_destination__: function ()
+   set_destination__ ()
    {
       this .assign (this .getBuffer (), 0, this .getDestination ());
 
       this .set_active (true);
    },
-   set_order__: function ()
+   set_order__ ()
    {
       var
          buffer = this .getBuffer (),
@@ -160,4 +159,18 @@ X3DDamperNode .prototype = Object .assign (Object .create (X3DFollowerNode .prot
    },
 });
 
+Object .defineProperties (X3DDamperNode,
+{
+   typeName:
+   {
+      value: "X3DDamperNode",
+      enumerable: true,
+   },
+   componentName:
+   {
+      value: "Followers",
+      enumerable: true,
+   },
+});
+
 export default X3DDamperNode;

package/src/x_ite/Components/Followers/X3DFollowerNode.js

@@ -61,60 +61,59 @@ function X3DFollowerNode (executionContext)
    this .vector = this .getVector ();
 }
 
-X3DFollowerNode .prototype = Object .assign (Object .create (X3DChildNode .prototype),
+Object .assign (Object .setPrototypeOf (X3DFollowerNode .prototype, X3DChildNode .prototype),
 {
-   constructor: X3DFollowerNode,
-   initialize: function ()
+   initialize ()
    {
       X3DChildNode .prototype .initialize .call (this);
 
       this .getLive () .addInterest ("set_live__", this);
    },
-   getBuffer: function ()
+   getBuffer ()
    {
       return this .buffer;
    },
-   getValue: function ()
+   getValue ()
    {
       return this ._set_value .getValue ();
    },
-   getDestination: function ()
+   getDestination ()
    {
       return this ._set_destination .getValue ();
    },
-   getInitialValue: function ()
+   getInitialValue ()
    {
       return this ._initialValue .getValue ();
    },
-   getInitialDestination: function ()
+   getInitialDestination ()
    {
       return this ._initialDestination .getValue ();
    },
-   setValue: function (value)
+   setValue (value)
    {
       this ._value_changed = value;
    },
-   setDestination: function (value)
+   setDestination (value)
    {
       this .destination .assign (value);
    },
-   duplicate: function (value)
+   duplicate (value)
    {
       return value .copy ();
    },
-   assign: function (buffer, i, value)
+   assign (buffer, i, value)
    {
       buffer [i] .assign (value);
    },
-   equals: function (lhs, rhs, tolerance)
+   equals (lhs, rhs, tolerance)
    {
       return this .a .assign (lhs) .subtract (rhs) .magnitude () < tolerance;
    },
-   interpolate: function (source, destination, weight)
+   interpolate (source, destination, weight)
    {
       return this .vector .assign (source) .lerp (destination, weight);
    },
-   set_live__: function ()
+   set_live__ ()
    {
       if ((this .getLive () .getValue () || this .isPrivate ()) && this ._isActive .getValue ())
       {
@@ -124,7 +123,7 @@ X3DFollowerNode .prototype = Object .assign (Object .create (X3DChildNode .proto
       else
          this .getBrowser () .prepareEvents () .removeInterest ("prepareEvents", this);
    },
-   set_active: function (value)
+   set_active (value)
    {
       if (value !== this ._isActive .getValue ())
       {
@@ -135,4 +134,18 @@ X3DFollowerNode .prototype = Object .assign (Object .create (X3DChildNode .proto
    },
 });
 
+Object .defineProperties (X3DFollowerNode,
+{
+   typeName:
+   {
+      value: "X3DFollowerNode",
+      enumerable: true,
+   },
+   componentName:
+   {
+      value: "Followers",
+      enumerable: true,
+   },
+});
+
 export default X3DFollowerNode;

package/src/x_ite/Components/Followers.js

@@ -45,7 +45,6 @@
  *
  ******************************************************************************/
 
-import SupportedNodes    from "../Configuration/SupportedNodes.js";
 import ColorChaser       from "./Followers/ColorChaser.js";
 import ColorDamper       from "./Followers/ColorDamper.js";
 import CoordinateChaser  from "./Followers/CoordinateChaser.js";
@@ -64,35 +63,29 @@ import X3DChaserNode     from "./Followers/X3DChaserNode.js";
 import X3DDamperNode     from "./Followers/X3DDamperNode.js";
 import X3DFollowerNode   from "./Followers/X3DFollowerNode.js";
 
-const Types =
-{
-   ColorChaser:       ColorChaser,
-   ColorDamper:       ColorDamper,
-   CoordinateChaser:  CoordinateChaser,
-   CoordinateDamper:  CoordinateDamper,
-   OrientationChaser: OrientationChaser,
-   OrientationDamper: OrientationDamper,
-   PositionChaser:    PositionChaser,
-   PositionChaser2D:  PositionChaser2D,
-   PositionDamper:    PositionDamper,
-   PositionDamper2D:  PositionDamper2D,
-   ScalarChaser:      ScalarChaser,
-   ScalarDamper:      ScalarDamper,
-   TexCoordChaser2D:  TexCoordChaser2D,
-   TexCoordDamper2D:  TexCoordDamper2D,
+export default {
+   name: "Followers",
+   concreteNodes:
+   [
+      ColorChaser,
+      ColorDamper,
+      CoordinateChaser,
+      CoordinateDamper,
+      OrientationChaser,
+      OrientationDamper,
+      PositionChaser,
+      PositionChaser2D,
+      PositionDamper,
+      PositionDamper2D,
+      ScalarChaser,
+      ScalarDamper,
+      TexCoordChaser2D,
+      TexCoordDamper2D,
+   ],
+   abstractNodes:
+   [
+      X3DChaserNode,
+      X3DDamperNode,
+      X3DFollowerNode,
+   ],
 };
-
-const AbstractTypes =
-{
-   X3DChaserNode: X3DChaserNode,
-   X3DDamperNode: X3DDamperNode,
-   X3DFollowerNode: X3DFollowerNode,
-};
-
-for (const typeName in Types)
-   SupportedNodes .addType (typeName, Types [typeName]);
-
-for (const typeName in AbstractTypes)
-   SupportedNodes .addAbstractType (typeName, AbstractTypes [typeName]);
-
-export default undefined;

package/src/x_ite/Components/Geometry2D/Arc2D.js

@@ -64,32 +64,9 @@ function Arc2D (executionContext)
    this ._radius     .setUnit ("length");
 }
 
-Arc2D .prototype = Object .assign (Object .create (X3DLineGeometryNode .prototype),
+Object .assign (Object .setPrototypeOf (Arc2D .prototype, X3DLineGeometryNode .prototype),
 {
-   constructor: Arc2D,
-   [Symbol .for ("X_ITE.X3DBaseNode.fieldDefinitions")]: new FieldDefinitionArray ([
-      new X3DFieldDefinition (X3DConstants .inputOutput,    "metadata",   new Fields .SFNode ()),
-      new X3DFieldDefinition (X3DConstants .initializeOnly, "startAngle", new Fields .SFFloat ()),
-      new X3DFieldDefinition (X3DConstants .initializeOnly, "endAngle",   new Fields .SFFloat (1.5708)),
-      new X3DFieldDefinition (X3DConstants .initializeOnly, "radius",     new Fields .SFFloat (1)),
-   ]),
-   getTypeName: function ()
-   {
-      return "Arc2D";
-   },
-   getComponentName: function ()
-   {
-      return "Geometry2D";
-   },
-   getContainerField: function ()
-   {
-      return "geometry";
-   },
-   getSpecificationRange: function ()
-   {
-      return ["3.0", "Infinity"];
-   },
-   set_live__: function ()
+   set_live__ ()
    {
       X3DLineGeometryNode .prototype .set_live__ .call (this);
 
@@ -98,7 +75,7 @@ Arc2D .prototype = Object .assign (Object .create (X3DLineGeometryNode .prototyp
       else
          this .getBrowser () .getArc2DOptions () .removeInterest ("requestRebuild", this);
    },
-   getSweepAngle: function ()
+   getSweepAngle ()
    {
       const
          start = Algorithm .interval (this ._startAngle .getValue (), 0, Math .PI * 2),
@@ -118,7 +95,7 @@ Arc2D .prototype = Object .assign (Object .create (X3DLineGeometryNode .prototyp
       // We must test for NAN, as NAN to int is undefined.
       return 0;
    },
-   build: function ()
+   build ()
    {
       const
          options     = this .getBrowser () .getArc2DOptions (),
@@ -148,4 +125,38 @@ Arc2D .prototype = Object .assign (Object .create (X3DLineGeometryNode .prototyp
    },
 });
 
+Object .defineProperties (Arc2D,
+{
+   typeName:
+   {
+      value: "Arc2D",
+      enumerable: true,
+   },
+   componentName:
+   {
+      value: "Geometry2D",
+      enumerable: true,
+   },
+   containerField:
+   {
+      value: "geometry",
+      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 .initializeOnly, "startAngle", new Fields .SFFloat ()),
+         new X3DFieldDefinition (X3DConstants .initializeOnly, "endAngle",   new Fields .SFFloat (1.5708)),
+         new X3DFieldDefinition (X3DConstants .initializeOnly, "radius",     new Fields .SFFloat (1)),
+      ]),
+      enumerable: true,
+   },
+});
+
 export default Arc2D;

package/src/x_ite/Components/Geometry2D/ArcClose2D.js

@@ -66,34 +66,9 @@ function ArcClose2D (executionContext)
    this ._radius     .setUnit ("length");
 }
 
-ArcClose2D .prototype = Object .assign (Object .create (X3DGeometryNode .prototype),
+Object .assign (Object .setPrototypeOf (ArcClose2D .prototype, X3DGeometryNode .prototype),
 {
-   constructor: ArcClose2D,
-   [Symbol .for ("X_ITE.X3DBaseNode.fieldDefinitions")]: new FieldDefinitionArray ([
-      new X3DFieldDefinition (X3DConstants .inputOutput,    "metadata",    new Fields .SFNode ()),
-      new X3DFieldDefinition (X3DConstants .initializeOnly, "closureType", new Fields .SFString ("PIE")),
-      new X3DFieldDefinition (X3DConstants .initializeOnly, "startAngle",  new Fields .SFFloat ()),
-      new X3DFieldDefinition (X3DConstants .initializeOnly, "endAngle",    new Fields .SFFloat (1.5708)),
-      new X3DFieldDefinition (X3DConstants .initializeOnly, "radius",      new Fields .SFFloat (1)),
-      new X3DFieldDefinition (X3DConstants .initializeOnly, "solid",       new Fields .SFBool ()),
-   ]),
-   getTypeName: function ()
-   {
-      return "ArcClose2D";
-   },
-   getComponentName: function ()
-   {
-      return "Geometry2D";
-   },
-   getContainerField: function ()
-   {
-      return "geometry";
-   },
-   getSpecificationRange: function ()
-   {
-      return ["3.0", "Infinity"];
-   },
-   set_live__: function ()
+   set_live__ ()
    {
       X3DGeometryNode .prototype .set_live__ .call (this);
 
@@ -102,7 +77,7 @@ ArcClose2D .prototype = Object .assign (Object .create (X3DGeometryNode .prototy
       else
          this .getBrowser () .getArcClose2DOptions () .removeInterest ("requestRebuild", this);
    },
-   getSweepAngle: function ()
+   getSweepAngle ()
    {
       const
          start = Algorithm .interval (this ._startAngle .getValue (), 0, Math .PI * 2),
@@ -213,4 +188,40 @@ ArcClose2D .prototype = Object .assign (Object .create (X3DGeometryNode .prototy
    })(),
 });
 
+Object .defineProperties (ArcClose2D,
+{
+   typeName:
+   {
+      value: "ArcClose2D",
+      enumerable: true,
+   },
+   componentName:
+   {
+      value: "Geometry2D",
+      enumerable: true,
+   },
+   containerField:
+   {
+      value: "geometry",
+      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 .initializeOnly, "closureType", new Fields .SFString ("PIE")),
+         new X3DFieldDefinition (X3DConstants .initializeOnly, "startAngle",  new Fields .SFFloat ()),
+         new X3DFieldDefinition (X3DConstants .initializeOnly, "endAngle",    new Fields .SFFloat (1.5708)),
+         new X3DFieldDefinition (X3DConstants .initializeOnly, "radius",      new Fields .SFFloat (1)),
+         new X3DFieldDefinition (X3DConstants .initializeOnly, "solid",       new Fields .SFBool ()),
+      ]),
+      enumerable: true,
+   },
+});
+
 export default ArcClose2D;

package/src/x_ite/Components/Geometry2D/Circle2D.js

@@ -60,30 +60,9 @@ function Circle2D (executionContext)
    this ._radius .setUnit ("length");
 }
 
-Circle2D .prototype = Object .assign (Object .create (X3DLineGeometryNode .prototype),
+Object .assign (Object .setPrototypeOf (Circle2D .prototype, X3DLineGeometryNode .prototype),
 {
-   constructor: Circle2D,
-   [Symbol .for ("X_ITE.X3DBaseNode.fieldDefinitions")]: new FieldDefinitionArray ([
-      new X3DFieldDefinition (X3DConstants .inputOutput,    "metadata", new Fields .SFNode ()),
-      new X3DFieldDefinition (X3DConstants .initializeOnly, "radius",   new Fields .SFFloat (1)),
-   ]),
-   getTypeName: function ()
-   {
-      return "Circle2D";
-   },
-   getComponentName: function ()
-   {
-      return "Geometry2D";
-   },
-   getContainerField: function ()
-   {
-      return "geometry";
-   },
-   getSpecificationRange: function ()
-   {
-      return ["3.0", "Infinity"];
-   },
-   set_live__: function ()
+   set_live__ ()
    {
       X3DLineGeometryNode .prototype .set_live__ .call (this);
 
@@ -92,7 +71,7 @@ Circle2D .prototype = Object .assign (Object .create (X3DLineGeometryNode .proto
       else
          this .getBrowser () .getCircle2DOptions () .removeInterest ("requestRebuild", this);
    },
-   build: function ()
+   build ()
    {
       const
          options     = this .getBrowser () .getCircle2DOptions (),
@@ -116,4 +95,36 @@ Circle2D .prototype = Object .assign (Object .create (X3DLineGeometryNode .proto
    },
 });
 
+Object .defineProperties (Circle2D,
+{
+   typeName:
+   {
+      value: "Circle2D",
+      enumerable: true,
+   },
+   componentName:
+   {
+      value: "Geometry2D",
+      enumerable: true,
+   },
+   containerField:
+   {
+      value: "geometry",
+      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 .initializeOnly, "radius",   new Fields .SFFloat (1)),
+      ]),
+      enumerable: true,
+   },
+});
+
 export default Circle2D;