x_ite 8.4.3 → 8.5.3

package/src/standard/Math/Numbers/Matrix3.js

@@ -575,6 +575,8 @@ Matrix3 .prototype =
       this [0] = 1; this [1] = 0; this [2] = 0;
       this [3] = 0; this [4] = 1; this [5] = 0;
       this [6] = 0; this [7] = 0; this [8] = 1;
+
+      return this;
    },
    translate: function (translation)
    {
@@ -589,9 +591,7 @@ Matrix3 .prototype =
    },
    rotate: function (rotation)
    {
-      this .multLeft (Matrix3 .Rotation (rotation));
-
-      return this;
+      return this .multLeft (Matrix3 .Rotation (rotation));
    },
    scale: function (scale)
    {
@@ -607,6 +607,14 @@ Matrix3 .prototype =
 
       return this;
    },
+   skewX: function (angle)
+   {
+      return this .multLeft (m .set (1, 0, 0, Math .tan (angle), 1, 0, 0, 0, 1));
+   },
+   skewY: function (angle)
+   {
+      return this .multLeft (m .set (1, Math .tan (angle), 0, 0, 1, 0, 0, 0, 1));
+   },
    toString: function ()
    {
       return this [0] + " " + this [1] + " " + this [2] + " " +

package/src/standard/Math/Numbers/Matrix4.js

@@ -47,6 +47,7 @@
 
 import Vector3             from "./Vector3.js";
 import Vector4             from "./Vector4.js";
+import Quaternion          from "./Quaternion.js";
 import Rotation4           from "./Rotation4.js";
 import Matrix3             from "./Matrix3.js";
 import eigen_decomposition from "../Algorithms/eigen_decomposition.js";
@@ -363,7 +364,7 @@ Matrix4 .prototype =
    })(),
    setRotation: function (rotation)
    {
-      return this .setQuaternion (rotation .value);
+      return this .setQuaternion (rotation .getQuaternion (q));
    },
    setQuaternion: function (quaternion)
    {
@@ -735,6 +736,8 @@ Matrix4 .prototype =
       this [ 4] = 0; this [ 5] = 1; this [ 6] = 0; this [ 7] = 0;
       this [ 8] = 0; this [ 9] = 0; this [10] = 1; this [11] = 0;
       this [12] = 0; this [13] = 0; this [14] = 0; this [15] = 1;
+
+      return this;
    },
    translate: function (translation)
    {
@@ -751,9 +754,7 @@ Matrix4 .prototype =
    },
    rotate: function (rotation)
    {
-      this .multLeft (m .setQuaternion (rotation .value));
-
-      return this;
+      return this .multLeft (m .setQuaternion (rotation .getQuaternion (q)));
    },
    scale: function (scale)
    {
@@ -914,7 +915,7 @@ Object .assign (Matrix4,
    Identity: new Matrix4 (),
    Rotation: function (rotation)
    {
-      return Object .create (this .prototype) .setQuaternion (rotation .value);
+      return Object .create (this .prototype) .setQuaternion (rotation .getQuaternion (q));
    },
    Quaternion: function (quaternion)
    {
@@ -945,6 +946,8 @@ Object .assign (Matrix4,
    },
 });
 
-const m = new Matrix4 ();
+const
+   q = new Quaternion (),
+   m = new Matrix4 ();
 
 export default Matrix4;

package/src/standard/Math/Numbers/Rotation4.js

@@ -51,10 +51,11 @@ import Vector4    from "./Vector4.js";
 import Algorithm  from "../Algorithm.js";
 
 const
-   _x     = Symbol (),
-   _y     = Symbol (),
-   _z     = Symbol (),
-   _angle = Symbol ();
+   _x          = Symbol (),
+   _y          = Symbol (),
+   _z          = Symbol (),
+   _angle      = Symbol (),
+   _quaternion = Symbol ();
 
 function Rotation4 (x, y, z, angle)
 {
@@ -67,12 +68,12 @@ function Rotation4 (x, y, z, angle)
    {
       case 0:
       {
-         this .value = new Quaternion (0, 0, 0, 1);
+         this [_quaternion] = new Quaternion (0, 0, 0, 1);
          return;
       }
       case 1:
       {
-         this .value = arguments [0];
+         this [_quaternion] = arguments [0];
          this .update ();
          return;
       }
@@ -82,7 +83,7 @@ function Rotation4 (x, y, z, angle)
             arg0 = arguments [0],
             arg1 = arguments [1];
 
-         this .value = new Quaternion (0, 0, 0, 1);
+         this [_quaternion] = new Quaternion (0, 0, 0, 1);
 
          if (arg1 instanceof Vector3)
             return this .setFromToVec (arg0, arg1);
@@ -96,7 +97,7 @@ function Rotation4 (x, y, z, angle)
       }
       case 4:
       {
-         this .value = new Quaternion (0, 0, 0, 1);
+         this [_quaternion] = new Quaternion (0, 0, 0, 1);
          this .set (x, y, z, angle);
          return;
       }
@@ -134,7 +135,7 @@ Rotation4 .prototype =
       copy [_z]     = this [_z];
       copy [_angle] = this [_angle];
 
-      copy .value  = this .value .copy ();
+      copy [_quaternion]  = this [_quaternion] .copy ();
 
       return copy;
    },
@@ -145,7 +146,7 @@ Rotation4 .prototype =
       this [_z]     = rotation [_z];
       this [_angle] = rotation [_angle];
 
-      this .value .assign (rotation .value);
+      this [_quaternion] .assign (rotation [_quaternion]);
 
       return this;
    },
@@ -160,7 +161,7 @@ Rotation4 .prototype =
 
       if (scale === 0)
       {
-         this .value .set (0, 0, 0, 1);
+         this [_quaternion] .set (0, 0, 0, 1);
          return this;
       }
 
@@ -170,10 +171,10 @@ Rotation4 .prototype =
          halfTheta = Algorithm .interval (angle / 2, 0, Math .PI),
          ascale    = Math .sin (halfTheta) / scale;
 
-      this .value .set (x * ascale,
-                        y * ascale,
-                        z * ascale,
-                        Math .cos (halfTheta));
+      this [_quaternion] .set (x * ascale,
+                               y * ascale,
+                               z * ascale,
+                               Math .cos (halfTheta));
       return this;
    },
    get: (function ()
@@ -182,16 +183,16 @@ Rotation4 .prototype =
 
       return function ()
       {
-         const value = this .value;
+         const quaternion = this [_quaternion];
 
-         if (Math .abs (value .w) > 1)
+         if (Math .abs (quaternion .w) > 1)
          {
             return Vector4 .zAxis;
          }
          else
          {
             const
-               angle = Math .acos (value .w) * 2,
+               angle = Math .acos (quaternion .w) * 2,
                scale = Math .sin (angle / 2);
 
             if (scale === 0)
@@ -200,7 +201,7 @@ Rotation4 .prototype =
             }
             else
             {
-               const axis = value .imag .divide (scale);
+               const axis = quaternion .imag .divide (scale);
 
                return result .set (axis .x,
                                    axis .y,
@@ -239,7 +240,7 @@ Rotation4 .prototype =
             // Parallel vectors
             // Check if they are pointing in the same direction.
             if (cos_angle > 0)
-               this .value .set (0, 0, 0, 1); // standard rotation
+               this [_quaternion] .set (0, 0, 0, 1); // standard rotation
 
             // Ok, so they are parallel and pointing in the opposite direction
             // of each other.
@@ -254,7 +255,7 @@ Rotation4 .prototype =
 
                t .normalize ();
 
-               this .value .set (t .x, t .y, t .z, 0);
+               this [_quaternion] .set (t .x, t .y, t .z, 0);
             }
          }
          else
@@ -264,10 +265,10 @@ Rotation4 .prototype =
             // which can lead to sqrt () returning NaN.
             crossvec .multiply (Math .sqrt (Math .abs (1 - cos_angle) / 2));
 
-            this .value .set (crossvec .x,
-                              crossvec .y,
-                              crossvec .z,
-                              Math .sqrt (Math .abs (1 + cos_angle) / 2));
+            this [_quaternion] .set (crossvec .x,
+                                     crossvec .y,
+                                     crossvec .z,
+                                     Math .sqrt (Math .abs (1 + cos_angle) / 2));
          }
 
          this .update ();
@@ -279,76 +280,82 @@ Rotation4 .prototype =
    {
       this .set (vector .x, vector .y, vector .z, this [_angle]);
    },
-   getAxis: (function ()
+   getAxis: function (axis)
    {
-      const axis = new Vector3 (0, 0, 0);
-
-      return function ()
-      {
-         return axis .set (this [_x], this [_y], this [_z]);
-      };
-   })(),
+      return axis .set (this [_x], this [_y], this [_z]);
+   },
+   setQuaternion: function (quaternion)
+   {
+      this [_quaternion] .assign (quaternion) .normalize ();
+      this .update ();
+      return this;
+   },
+   getQuaternion: function (quaternion)
+   {
+      quaternion .assign (this [_quaternion]);
+      return quaternion;
+   },
    setMatrix: function (matrix)
    {
-      this .value .setMatrix (matrix) .normalize ();
+      this [_quaternion] .setMatrix (matrix) .normalize ();
       this .update ();
       return this;
    },
    getMatrix: function (matrix)
    {
-      return this .value .getMatrix (matrix);
+      return this [_quaternion] .getMatrix (matrix);
    },
-   equals: function (rot)
+   equals: function (rotation)
    {
-      return this .value .equals (rot .value);
+      return this [_quaternion] .equals (rotation [_quaternion]);
    },
    inverse: function ()
    {
-      this .value .inverse ();
+      this [_quaternion] .inverse ();
       this .update ();
       return this;
    },
    multLeft: function (rotation)
    {
-      this .value .multLeft (rotation .value) .normalize ();
+      this [_quaternion] .multLeft (rotation [_quaternion]) .normalize ();
       this .update ();
       return this;
    },
    multRight: function (rotation)
    {
-      this .value .multRight (rotation .value) .normalize ();
+      this [_quaternion] .multRight (rotation [_quaternion]) .normalize ();
       this .update ();
       return this;
    },
    multVecRot: function (vector)
    {
-      return this .value .multVecQuat (vector);
+      return this [_quaternion] .multVecQuat (vector);
    },
    multRotVec: function (vector)
    {
-      return this .value .multQuatVec (vector);
+      return this [_quaternion] .multQuatVec (vector);
    },
    normalize: function ()
    {
-      this .value .normalize ();
+      this [_quaternion] .normalize ();
       this .update ();
       return this;
    },
    pow: function (exponent)
    {
-      this .value .pow (exponent);
+      this [_quaternion] .pow (exponent);
       this .update ();
       return this;
    },
    slerp: function (dest, t)
    {
-      this .value .slerp (dest .value, t);
+      this [_quaternion] .slerp (dest [_quaternion], t);
       this .update ();
       return this;
    },
-   squad: function (a ,b, dest, t)
+   squad: function (a, b, dest, t)
    {
-      this .value .squad (a .value, b .value, dest .value, t);
+      this [_quaternion] .squad (a [_quaternion], b [_quaternion], dest [_quaternion], t);
       this .update ();
       return this;
    },
@@ -366,10 +373,10 @@ const x = {
    {
       return this [_x];
    },
-   set: function (value)
+   set: function (x)
    {
-      this [_x] = value;
-      this .set (value, this [_y], this [_z], this [_angle]);
+      this [_x] = x;
+      this .set (x, this [_y], this [_z], this [_angle]);
    },
    enumerable: true,
    configurable: false
@@ -380,10 +387,10 @@ const y = {
    {
       return this [_y];
    },
-   set: function (value)
+   set: function (y)
    {
-      this [_y] = value;
-      this .set (this [_x], value, this [_z], this [_angle]);
+      this [_y] = y;
+      this .set (this [_x], y, this [_z], this [_angle]);
    },
    enumerable: true,
    configurable: false
@@ -394,10 +401,10 @@ const z = {
    {
       return this [_z];
    },
-   set: function (value)
+   set: function (z)
    {
-      this [_z] = value;
-      this .set (this [_x], this [_y], value, this [_angle]);
+      this [_z] = z;
+      this .set (this [_x], this [_y], z, this [_angle]);
    },
    enumerable: true,
    configurable: false
@@ -408,18 +415,18 @@ const angle = {
    {
       return this [_angle];
    },
-   set: function (value)
+   set: function (angle)
    {
-      this [_angle] = value;
-      this .set (this [_x], this [_y], this [_z], value);
+      this [_angle] = angle;
+      this .set (this [_x], this [_y], this [_z], angle);
    },
    enumerable: true,
    configurable: false
 };
 
-Object .defineProperty (Rotation4 .prototype, "x", x);
-Object .defineProperty (Rotation4 .prototype, "y", y);
-Object .defineProperty (Rotation4 .prototype, "z", z);
+Object .defineProperty (Rotation4 .prototype, "x",     x);
+Object .defineProperty (Rotation4 .prototype, "y",     y);
+Object .defineProperty (Rotation4 .prototype, "z",     z);
 Object .defineProperty (Rotation4 .prototype, "angle", angle);
 
 x     .enumerable = false;
@@ -459,15 +466,15 @@ Object .assign (Rotation4,
    bezier: function (source, a, b, destination, t)
    {
       const copy = Object .create (this .prototype);
-      copy .value = Quaternion .bezier (source .value, a, b, destination .value, t);
+      copy [_quaternion] = Quaternion .bezier (source [_quaternion], a, b, destination [_quaternion], t);
       copy .update ();
       return copy;
    },
    */
-   spline: function (q0, q1, q2)
+   spline: function (r0, r1, r2)
    {
       const copy = Object .create (this .prototype);
-      copy .value = Quaternion .spline (q0 .value, q1 .value, q2 .value);
+      copy [_quaternion] = Quaternion .spline (r0 [_quaternion], r1 [_quaternion], r2 [_quaternion]);
       copy .update ();
       return copy;
    },

package/src/tests.js

@@ -141,6 +141,7 @@ const X_ITE_TESTS = [
    { component: "Networking" },
    { path: "Networking/Anchor.x3d" },
    { path: "Networking/autoRefresh.x3dv" },
+   { path: "Networking/BoxWithLight.x3d" },
    { path: "Networking/InlineGlobal.x3d" },
    { path: "Networking/LoadSensor.x3d" },
    { component: "NURBS" },
@@ -218,6 +219,7 @@ const X_ITE_TESTS = [
    { component: "PROTO" },
    { path: "PROTO/27cubes.x3d" },
    { path: "PROTO/cbx.wrl" },
+   { path: "PROTO/CustomBox.x3dv" },
    { path: "PROTO/Double.x3dv" },
    { path: "PROTO/ExternProto.x3d" },
    { path: "PROTO/ExternProto.x3dv" },
@@ -327,6 +329,7 @@ const X_ITE_TESTS = [
    { path: "TextureProjector/Parallel.x3d" },
    { path: "TextureProjector/Perspective.x3d" },
    { component: "Texturing" },
+   { path: "Texturing/AnimatedGIF.x3dv" },
    { path: "Texturing/ColorManagement.x3d" },
    { path: "Texturing/ColorMaterial.x3d" },
    { path: "Texturing/DataURL.x3d" },

package/src/x_ite/Base/X3DArrayField.js

@@ -77,10 +77,8 @@ X3DArrayField .prototype = Object .assign (Object .create (X3DField .prototype),
    map: Array .prototype .map,
    reduce: Array .prototype .reduce,
    reduceRight: Array .prototype .reduceRight,
-   //Array.prototype.reverse
    slice: Array .prototype .slice,
    some: Array .prototype .some,
-   //Array.prototype.sort
    values: Array .prototype .values,
 });
 

package/src/x_ite/Base/X3DInfoArray.js

@@ -277,7 +277,7 @@ X3DInfoArray .prototype = {
    {
       let lastProperty = false;
 
-      for (const value of this [_array])
+      for (const [i, value] of this [_array] .entries ())
       {
          try
          {
@@ -295,7 +295,7 @@ X3DInfoArray .prototype = {
       }
 
       if (lastProperty && !comma)
-         generator .string = generator .string .replace (/,(\s*)$/s, "$1");
+         generator .JSONRemoveComma ();
 
       return lastProperty;
    },

package/src/x_ite/Base/X3DObjectArrayField.js

@@ -47,6 +47,7 @@
 
 import X3DField      from "./X3DField.js";
 import X3DArrayField from "./X3DArrayField.js";
+import Algorithm     from "../../standard/Math/Algorithm.js";
 
 const
    _target = Symbol (),
@@ -444,6 +445,24 @@ X3DObjectArrayField .prototype = Object .assign (Object .create (X3DArrayField .
             target .addEvent ();
       }
    },
+   reverse: function ()
+   {
+      const target = this [_target];
+
+      target .getValue () .reverse ();
+      target .addEvent ();
+
+      return this;
+   },
+   sort: function ()
+   {
+      const target = this [_target];
+
+      target .getValue () .sort ((a, b) => Algorithm .cmp (a .valueOf (), b .valueOf ()));
+      target .addEvent ();
+
+      return this;
+   },
    addChildObject: function (value)
    {
       value .addParent (this [_proxy]);

package/src/x_ite/Base/X3DTypedArrayField.js

@@ -687,6 +687,155 @@ X3DTypedArrayField .prototype = Object .assign (Object .create (X3DArrayField .p
 
       return newArray;
    },
+   includes: function (searchElement, fromIndex)
+   {
+      const
+         target     = this [_target],
+         components = target .getComponents (),
+         length     = target [_length];
+
+      if (components === 1)
+      {
+         return Array .prototype .includes .call (this, searchElement, fromIndex);
+      }
+      else
+      {
+         for (let i = fromIndex === undefined ? 0 : fromIndex; i < length; ++ i)
+         {
+            if (this [i] .equals (searchElement))
+               return true;
+         }
+
+         return false;
+      }
+   },
+   indexOf: function (searchElement, fromIndex)
+   {
+      const
+         target     = this [_target],
+         components = target .getComponents (),
+         length     = target [_length];
+
+      if (components === 1)
+      {
+         return Array .prototype .indexOf .call (this, searchElement, fromIndex);
+      }
+      else
+      {
+         for (let i = fromIndex === undefined ? 0 : fromIndex; i < length; ++ i)
+         {
+            if (this [i] .equals (searchElement))
+               return i;
+         }
+
+         return -1;
+      }
+   },
+   lastIndexOf: function (searchElement, fromIndex)
+   {
+      const
+         target     = this [_target],
+         components = target .getComponents (),
+         length     = target [_length];
+
+      if (components === 1)
+      {
+         return Array .prototype .lastIndexOf .call (this, searchElement, fromIndex);
+      }
+      else
+      {
+         for (let i = fromIndex === undefined ? length - 1 : fromIndex; i >= 0; -- i)
+         {
+            if (this [i] .equals (searchElement))
+               return i;
+         }
+
+         return -1;
+      }
+   },
+   reverse: function ()
+   {
+      const
+         target     = this [_target],
+         array      = target .getValue (),
+         components = target .getComponents (),
+         length     = target [_length] * components,
+         length1_2  = Math .floor (target [_length] / 2) * components;
+
+      if (components === 1)
+      {
+         for (let i = 0; i < length1_2; ++ i)
+         {
+            const
+               i2 = length - i - 1,
+               t  = array [i];
+
+            array [i]  = array [i2];
+            array [i2] = t;
+         }
+      }
+      else
+      {
+         for (let i = 0; i < length1_2; i += components)
+         {
+            for (let c = 0; c < components; ++ c)
+            {
+               const
+                  i1 = i + c,
+                  i2 = length - (components - i - c - 1) - 1,
+                  t  = array [i1];
+
+               array [i1] = array [i2];
+               array [i2] = t;
+            }
+         }
+      }
+
+      target .addEvent ();
+
+      return this;
+   },
+   sort: function (compareFunction)
+   {
+      const
+         target     = this [_target],
+         array      = target .getValue (),
+         components = target .getComponents (),
+         length     = target [_length];
+
+      if (components === 1)
+      {
+         target .set (array .subarray (0, length) .sort (compareFunction));
+      }
+      else
+      {
+         const result = this .map (value => value .copy ()) .sort (compareFunction !== undefined ? compareFunction : function (a, b)
+         {
+            for (let c = 0; c < components; ++ c)
+            {
+               if (a [c] < b [c])
+                  return -1;
+
+               if (b [c] < a [c])
+                  return 1;
+            }
+
+            return 0;
+         });
+
+         for (let i = 0; i < length; ++ i)
+         {
+            const value = result [i];
+
+            for (let c = 0, first = i * components; c < components; ++ c, ++ first)
+               array [first] = value [c];
+         }
+      }
+
+      target .addEvent ();
+
+      return this;
+   },
    toStream: function (generator)
    {
       const