x_ite 8.9.5 → 8.10.0

package/src/x_ite/Components/HAnim/HAnimHumanoid.js

@@ -55,8 +55,6 @@ import X3DBoundedObject     from "../Grouping/X3DBoundedObject.js";
 import TraverseType         from "../../Rendering/TraverseType.js";
 import X3DConstants         from "../../Base/X3DConstants.js";
 import X3DCast              from "../../Base/X3DCast.js";
-import Vector3              from "../../../standard/Math/Numbers/Vector3.js";
-import Rotation4            from "../../../standard/Math/Numbers/Rotation4.js";
 import Matrix4              from "../../../standard/Math/Numbers/Matrix4.js";
 
 function HAnimHumanoid (executionContext)
@@ -66,6 +64,10 @@ function HAnimHumanoid (executionContext)
 
    this .addType (X3DConstants .HAnimHumanoid);
 
+   this .addChildObjects (X3DConstants .inputOutput, "jointTextures",              new Fields .SFTime (),
+                          X3DConstants .inputOutput, "displacementsTexture",       new Fields .SFTime (),
+                          X3DConstants .inputOutput, "displacementWeightsTexture", new Fields .SFTime ());
+
    this ._translation .setUnit ("length");
    this ._center      .setUnit ("length");
    this ._bboxSize    .setUnit ("length");
@@ -77,11 +79,10 @@ function HAnimHumanoid (executionContext)
    this .transformNode        = new Transform (executionContext);
    this .jointNodes           = [ ];
    this .jointBindingMatrices = [ ];
-   this .skinBindingNormal    = null;
-   this .skinBindingCoord     = null;
-   this .skinNormalNode       = null;
+   this .displacementWeights  = [ ];
    this .skinCoordNode        = null;
-   this .changed              = false;
+   this .change               = new Lock ();
+   this .skinning             = Function .prototype;
 }
 
 Object .assign (Object .setPrototypeOf (HAnimHumanoid .prototype, X3DChildNode .prototype),
@@ -145,25 +146,64 @@ Object .assign (Object .setPrototypeOf (HAnimHumanoid .prototype, X3DChildNode .
       this .setCameraObject   (this .transformNode .isCameraObject ());
       this .setPickableObject (this .transformNode .isPickableObject ());
 
-      // Skinning
+      // Check WebGL version.
+
+      const
+         browser = this .getBrowser (),
+         gl      = browser .getContext ();
+
+      if (gl .getVersion () === 1)
+         return;
+
+      // Prepare skinNode.
+
+      this .skinNode .traverse = function (humanoidNode, type, renderObject)
+      {
+         renderObject .getHumanoids () .push (humanoidNode);
+
+         Group .prototype .traverse .call (this, type, renderObject);
+
+         renderObject .getHumanoids () .pop ();
+      }
+      .bind (this .skinNode, this);
 
-      this ._joints                .addInterest ("set_joints__",            this);
-      this ._jointBindingPositions .addInterest ("set_joints__",            this);
-      this ._jointBindingRotations .addInterest ("set_joints__",            this);
-      this ._jointBindingScales    .addInterest ("set_joints__",            this);
-      this ._skinBindingNormal     .addInterest ("set_skinBindingNormal__", this);
-      this ._skinBindingCoord      .addInterest ("set_skinBindingCoord__",  this);
-      this ._skinNormal            .addInterest ("set_skinNormal__",        this);
-      this ._skinCoord             .addInterest ("set_skinCoord__",         this);
+      // Textures
+
+      this .jointsTexture        = gl .createTexture ();
+      this .displacementsTexture = gl .createTexture ();
+      this .jointMatricesTexture = gl .createTexture ();
+
+      for (const texture of [this .jointsTexture, this .displacementsTexture, this .jointMatricesTexture])
+      {
+         gl .bindTexture (gl .TEXTURE_2D, texture);
+         gl .texParameteri (gl .TEXTURE_2D, gl .TEXTURE_WRAP_S,     gl .CLAMP_TO_EDGE);
+         gl .texParameteri (gl .TEXTURE_2D, gl .TEXTURE_WRAP_T,     gl .CLAMP_TO_EDGE);
+         gl .texParameteri (gl .TEXTURE_2D, gl .TEXTURE_MIN_FILTER, gl .LINEAR);
+         gl .texParameteri (gl .TEXTURE_2D, gl .TEXTURE_MAG_FILTER, gl .LINEAR);
+      }
+
+      // Events
+
+      this ._joints                     .addInterest ("set_joints__",                     this);
+      this ._jointBindingPositions      .addInterest ("set_joints__",                     this);
+      this ._jointBindingRotations      .addInterest ("set_joints__",                     this);
+      this ._jointBindingScales         .addInterest ("set_joints__",                     this);
+      this ._jointTextures              .addInterest ("set_jointTextures__",              this);
+      this ._displacementsTexture       .addInterest ("set_displacementsTexture__",       this);
+      this ._displacementWeightsTexture .addInterest ("set_displacementWeightsTexture__", this);
+      this ._skinCoord                  .addInterest ("set_skinCoord__",                  this);
 
       this .set_joints__ ();
-      this .set_skinBindingNormal__ ();
-      this .set_skinBindingCoord__ ();
+      this .set_skinCoord__ ();
    },
    getBBox (bbox, shadows)
    {
       return this .transformNode .getBBox (bbox, shadows);
    },
+   getMatrix ()
+   {
+      return this .transformNode .getMatrix ();
+   },
    set_joints__ ()
    {
       const
@@ -174,7 +214,13 @@ Object .assign (Object .setPrototypeOf (HAnimHumanoid .prototype, X3DChildNode .
          jointBindingScales    = this ._jointBindingScales;
 
       for (const jointNode of jointNodes)
-         jointNode .removeInterest ("set_joint__", this);
+      {
+         jointNode .removeInterest ("enable", this .change);
+         jointNode ._skinCoordIndex      .removeInterest ("addEvent", this ._jointTextures);
+         jointNode ._skinCoordWeight     .removeInterest ("addEvent", this ._jointTextures);
+         jointNode ._displacements       .removeInterest ("addEvent", this ._displacementsTexture);
+         jointNode ._displacementWeights .removeInterest ("addEvent", this ._displacementWeightsTexture);
+      }
 
       jointNodes           .length = 0;
       jointBindingMatrices .length = 0;
@@ -183,67 +229,219 @@ Object .assign (Object .setPrototypeOf (HAnimHumanoid .prototype, X3DChildNode .
       {
          const jointNode = X3DCast (X3DConstants .HAnimJoint, node);
 
-         if (jointNode)
-         {
-            const jointBindingMatrix = new Matrix4 ();
+         if (!jointNode)
+            continue;
 
-            if (jointBindingPositions .length)
-               jointBindingMatrix .translate (jointBindingPositions [Math .min (i, jointBindingPositions .length - 1)] .getValue ());
+         const jointBindingMatrix = new Matrix4 ();
 
-            if (jointBindingRotations .length)
-               jointBindingMatrix .rotate (jointBindingRotations [Math .min (i, jointBindingRotations .length - 1)] .getValue ());
+         if (jointBindingPositions .length)
+            jointBindingMatrix .translate (jointBindingPositions [Math .min (i, jointBindingPositions .length - 1)] .getValue ());
 
-            if (jointBindingScales .length)
-               jointBindingMatrix .scale (jointBindingScales [Math .min (i, jointBindingScales .length - 1)] .getValue ());
+         if (jointBindingRotations .length)
+            jointBindingMatrix .rotate (jointBindingRotations [Math .min (i, jointBindingRotations .length - 1)] .getValue ());
 
-            jointNodes           .push (jointNode);
-            jointBindingMatrices .push (jointBindingMatrix);
-         }
+         if (jointBindingScales .length)
+            jointBindingMatrix .scale (jointBindingScales [Math .min (i, jointBindingScales .length - 1)] .getValue ());
+
+         jointNodes           .push (jointNode);
+         jointBindingMatrices .push (jointBindingMatrix);
       }
 
       for (const jointNode of jointNodes)
-         jointNode .addInterest ("set_joint__", this);
+      {
+         jointNode .addInterest ("enable", this .change);
+         jointNode ._skinCoordIndex      .addInterest ("addEvent", this ._jointTextures);
+         jointNode ._skinCoordWeight     .addInterest ("addEvent", this ._jointTextures);
+         jointNode ._displacements       .addInterest ("addEvent", this ._displacementsTexture);
+         jointNode ._displacementWeights .addInterest ("addEvent", this ._displacementWeightsTexture);
+      }
 
-      this .set_joint__ ();
-   },
-   set_joint__ ()
-   {
-      this .changed = true;
+      const size = Math .ceil (Math .sqrt (jointNodes .length * 8));
+
+      this .jointMatricesArray = new Float32Array (size * size * 4),
+
+      this ._jointTextures              .addEvent ();
+      this ._displacementsTexture       .addEvent ();
+      this ._displacementWeightsTexture .addEvent ();
    },
-   set_skinBindingNormal__ ()
+   set_jointTextures__ ()
    {
-      this .skinBindingNormal = X3DCast (X3DConstants .X3DNormalNode, this ._skinBindingNormal);
+      // Create arrays.
+
+      const
+         length  = this .skinCoordNode ?._point .length || 1,
+         joints  = Array .from ({ length }, () => [ ]),
+         weights = Array .from ({ length }, () => [ ]);
+
+      for (const [j, jointNode] of this .jointNodes .entries ())
+      {
+         const skinCoordWeight = jointNode ._skinCoordWeight .getValue ();
+
+         for (const [i, index] of jointNode ._skinCoordIndex .entries ())
+         {
+            joints  [index] ?.push (j);
+            weights [index] ?.push (skinCoordWeight [i])
+         }
+      }
 
-      this .set_skinNormal__ ();
+      const
+         size        = Math .ceil (Math .sqrt (length * 2)) || 1,
+         jointsArray = new Float32Array (size * size * 4);
+
+      for (let i = 0; i < length; ++ i)
+      {
+         const j = joints [i], w = weights [i];
+
+         j .length = w .length = Math .min (j .length, 4);
+
+         jointsArray .set (j, i * 8 + 0);
+         jointsArray .set (w, i * 8 + 4);
+      }
+
+      // Upload textures.
+
+      const
+         browser = this .getBrowser (),
+         gl      = browser .getContext ();
+
+      gl .bindTexture (gl .TEXTURE_2D, this .jointsTexture);
+      gl .texImage2D (gl .TEXTURE_2D, 0, gl .RGBA32F, size, size, 0, gl .RGBA, gl .FLOAT, jointsArray);
+
+      // Trigger update.
+
+      this .change .enable ();
    },
-   set_skinBindingCoord__ ()
+   set_displacementsTexture__ ()
    {
-      this .skinBindingCoord = X3DCast (X3DConstants .X3DCoordinateNode, this ._skinBindingCoord);
+      // Create array.
 
-      this .set_skinCoord__ ();
+      const
+         length        = this .skinCoordNode ?._point .length || 1,
+         displacements = Array .from ({ length }, () => [ ]);
+
+      for (const [j, jointNode] of this .jointNodes .entries ())
+      {
+         for (const displacerNode of jointNode .getDisplacers ())
+         {
+            const d = displacerNode ._displacements;
+
+            for (const [i, index] of displacerNode ._coordIndex .entries ())
+               displacements [index] ?.push (... d [i]);
+         }
+      }
+
+      const
+         size               = even (Math .ceil (Math .sqrt (length * 2)) || 1),
+         displacementsArray = new Float32Array (size * size * 8);
+
+      for (let i = 0; i < length; ++ i)
+      {
+         const d = displacements [i];
+
+         d .length = Math .min (d .length, 8);
+
+         displacementsArray .set (d, i * 8);
+      }
+
+      // Upload texture.
+
+      const
+         browser = this .getBrowser (),
+         gl      = browser .getContext ();
+
+      gl .bindTexture (gl .TEXTURE_2D, this .displacementsTexture);
+      gl .texImage2D (gl .TEXTURE_2D, 0, gl .RGBA32F, size, size, 0, gl .RGBA, gl .FLOAT, displacementsArray);
+
+      // Weights
+
+      const displacementWeights = this .displacementWeights;
+
+      for (let i = displacementWeights .length; i < length; ++ i)
+         displacementWeights [i] = [ ];
+
+      displacementWeights .length = length;
+
+      this .displacementWeightsArray = new Float32Array (size * size * 4);
+
+      // Trigger update.
+
+      this .change .enable ();
    },
-   set_skinNormal__ ()
+   set_displacementWeightsTexture__ ()
    {
-      this .skinNormalNode = X3DCast (X3DConstants .X3DNormalNode, this ._skinNormal);
+      // Create array.
 
-      if (!this .skinBindingNormal && this .skinNormalNode)
-         this .skinBindingNormal = this .skinNormalNode .copy ();
+      const
+         length              = this .skinCoordNode ?._point .length || 1,
+         displacementWeights = this .displacementWeights;
+
+      for (const d of displacementWeights)
+         d .length = 0;
+
+      for (const jointNode of this .jointNodes)
+      {
+         for (const displacerNode of jointNode .getDisplacers ())
+         {
+            const weight = displacerNode ._weight;
+
+            for (const index of displacerNode ._coordIndex)
+               displacementWeights [index] ?.push (weight);
+         }
+      }
+
+      const
+         size                     = even (Math .ceil (Math .sqrt (length * 2)) || 1),
+         displacementWeightsArray = this .displacementWeightsArray;
+
+      for (let i = 0; i < length; ++ i)
+      {
+         const d = displacementWeights [i];
+
+         d .length = Math .min (d .length, 8);
+
+         displacementWeightsArray .set (d, i * 8);
+      }
+
+      // Upload texture.
+
+      const
+         browser = this .getBrowser (),
+         gl      = browser .getContext ();
+
+      gl .bindTexture (gl .TEXTURE_2D, this .displacementsTexture);
+      gl .texSubImage2D (gl .TEXTURE_2D, 0, 0, size / 2, size, size / 2, gl .RGBA, gl .FLOAT, displacementWeightsArray)
 
-      this .changed = true;
+      // Trigger update.
+
+      this .change .enable ();
    },
    set_skinCoord__ ()
    {
-      this .skinCoordNode = X3DCast (X3DConstants .X3DCoordinateNode, this ._skinCoord);
+      if (this .skinCoordNode)
+      {
+         this .skinCoordNode .removeInterest ("addEvent", this ._jointTextures);
+         this .skinCoordNode .removeInterest ("addEvent", this ._displacementsTexture);
+         this .skinCoordNode .removeInterest ("addEvent", this ._displacementWeightsTexture);
+      }
 
-      if (!this .skinBindingCoord && this .skinCoordNode)
-         this .skinBindingCoord = this .skinCoordNode .copy ();
+      this .skinCoordNode = X3DCast (X3DConstants .X3DCoordinateNode, this ._skinCoord);
 
       if (this .skinCoordNode)
+      {
          delete this .skinning;
+
+         this .skinCoordNode .addInterest ("addEvent", this ._jointTextures);
+         this .skinCoordNode .addInterest ("addEvent", this ._displacementsTexture);
+         this .skinCoordNode .addInterest ("addEvent", this ._displacementWeightsTexture);
+      }
       else
-         this .skinning = Function .prototype
+      {
+         this .skinning = Function .prototype;
+      }
 
-      this .changed = true;
+      this ._jointTextures              .addEvent ();
+      this ._displacementsTexture       .addEvent ();
+      this ._displacementWeightsTexture .addEvent ();
    },
    traverse (type, renderObject)
    {
@@ -253,136 +451,67 @@ Object .assign (Object .setPrototypeOf (HAnimHumanoid .prototype, X3DChildNode .
    },
    skinning: (() =>
    {
-      const
-         invModelMatrix = new Matrix4 (),
-         rest           = new Vector3 (0, 0, 0),
-         skin           = new Vector3 (0, 0, 0),
-         vector         = new Vector3 (0, 0, 0),
-         point          = new Vector3 (0, 0, 0);
+      const invModelViewMatrix = new Matrix4 ();
 
       return function (type, renderObject)
       {
-         if (type !== TraverseType .CAMERA)
+         if (type !== TraverseType .DISPLAY || this .change .lock ())
             return;
 
-         if (!this .changed)
-            return;
+         // Determine inverse model matrix of humanoid.
 
-         this .changed = false;
+         invModelViewMatrix .assign (this .transformNode .getMatrix ())
+            .multRight (renderObject .getModelViewMatrix () .get ()) .inverse ();
+
+         // Create joint matrices.
 
          const
             jointNodes           = this .jointNodes,
             jointNodesLength     = jointNodes .length,
             jointBindingMatrices = this .jointBindingMatrices,
-            skinBindingNormal    = this .skinBindingNormal,
-            skinBindingCoord     = this .skinBindingCoord,
-            skinNormalNode       = this .skinNormalNode,
-            skinCoordNode        = this .skinCoordNode;
-
-         // Reset skin normals and coords.
-
-         if (skinNormalNode)
-            skinNormalNode ._vector .assign (skinBindingNormal ._vector);
-
-         skinCoordNode ._point .assign (skinBindingCoord ._point);
-
-         // Determine inverse model matrix of humanoid.
-
-         invModelMatrix .assign (this .transformNode .getMatrix ())
-            .multRight (renderObject .getModelViewMatrix () .get ()) .inverse ();
-
-         // Apply joint transformations.
+            jointMatricesArray   = this .jointMatricesArray,
+            size                 = Math .ceil (Math .sqrt (jointNodesLength * 8));
 
          for (let i = 0; i < jointNodesLength; ++ i)
          {
             const
-               jointNode            = jointNodes [i],
-               jointBindingMatrix   = jointBindingMatrices [i],
-               jointMatrix          = jointNode .getModelMatrix () .multRight (invModelMatrix) .multLeft (jointBindingMatrix),
-               displacerNodes       = jointNode .getDisplacers (),
-               skinCoordIndexLength = jointNode ._skinCoordIndex .length;
-
-            for (const displacerNode of displacerNodes)
-            {
-               const
-                  coordIndex          = displacerNode ._coordIndex .getValue (),
-                  coordIndexLength    = displacerNode ._coordIndex .length,
-                  weight              = displacerNode ._weight .getValue (),
-                  displacements       = displacerNode ._displacements .getValue (),
-                  displacementsLength = displacerNode ._displacements .length;
-
-               for (let i = 0; i < coordIndexLength; ++ i)
-               {
-                  const
-                     i3           = i * 3,
-                     index        = coordIndex [i],
-                     displacement = i < displacementsLength ? point .set (displacements [i3], displacements [i3 + 1], displacements [i3 + 2]) : point .assign (Vector3 .Zero);
-
-                  skinCoordNode .get1Point (index, skin);
-                  jointMatrix .multDirMatrix (displacement) .multiply (weight) .add (skin);
-                  skinCoordNode .set1Point (index, displacement);
-               }
-            }
+               jointNode          = jointNodes [i],
+               jointBindingMatrix = jointBindingMatrices [i],
+               jointMatrix        = jointNode .getModelViewMatrix () .multRight (invModelViewMatrix) .multLeft (jointBindingMatrix),
+               jointNormalMatrix  = jointMatrix .submatrix .transpose () .inverse ();
 
-            const
-               normalMatrix          = skinNormalNode ? jointMatrix .submatrix .transpose () .inverse () : null,
-               skinCoordIndex        = jointNode ._skinCoordIndex .getValue (),
-               skinCoordWeight       = jointNode ._skinCoordWeight .getValue (),
-               skinCoordWeightLength = jointNode ._skinCoordWeight .length;
-
-            for (let i = 0; i < skinCoordIndexLength; ++ i)
-            {
-               const
-                  index  = skinCoordIndex [i],
-                  weight = i < skinCoordWeightLength ? skinCoordWeight [i] : 1;
-
-               if (skinNormalNode)
-               {
-                  rest .assign (skinBindingNormal .get1Vector (index, vector));
-                  skinNormalNode .get1Vector (index, skin);
-                  normalMatrix .multVecMatrix (vector) .subtract (rest) .multiply (weight) .add (skin);
-                  skinNormalNode .set1Vector (index, vector);
-                  // Let the shader normalize the normals.
-               }
-
-               //skin += (rest * J - rest) * weight
-               rest .assign (skinBindingCoord .get1Point (index, point));
-               skinCoordNode .get1Point (index, skin);
-               jointMatrix .multVecMatrix (point) .subtract (rest) .multiply (weight) .add (skin);
-               skinCoordNode .set1Point (index, point);
-            }
+            jointMatricesArray .set (jointMatrix,       i * 32 + 0);
+            jointMatricesArray .set (jointNormalMatrix, i * 32 + 16);
          }
-      };
-   })(),
-   toVRMLStream (generator)
-   {
-      if (this .skinNormalNode)
-         this .skinNormalNode ._vector = this .skinBindingNormal ._vector;
 
-      if (this .skinCoordNode)
-         this .skinCoordNode ._point = this .skinBindingCoord ._point;
+         // Upload textures.
 
-      X3DChildNode .prototype .toVRMLStream .call (this, generator);
-   },
-   toXMLStream (generator)
-   {
-      if (this .skinNormalNode)
-         this .skinNormalNode ._vector = this .skinBindingNormal ._vector;
-
-      if (this .skinCoordNode)
-         this .skinCoordNode ._point = this .skinBindingCoord ._point;
+         const
+            browser = this .getBrowser (),
+            gl      = browser .getContext ();
 
-      X3DChildNode .prototype .toXMLStream .call (this, generator);
-   },
-   toJSONStream (generator)
+         gl .bindTexture (gl .TEXTURE_2D, this .jointMatricesTexture);
+         gl .texImage2D (gl .TEXTURE_2D, 0, gl .RGBA32F, size, size, 0, gl .RGBA, gl .FLOAT, jointMatricesArray);
+      };
+   })(),
+   setShaderUniforms (gl, shaderObject)
    {
-      if (this .skinNormalNode)
-         this .skinNormalNode ._vector = this .skinBindingNormal ._vector;
+      const
+         jointsTextureTextureUnit        = this .getBrowser () .getTexture2DUnit (),
+         displacementsTextureTextureUnit = this .getBrowser () .getTexture2DUnit (),
+         jointMatricesTextureUnit        = this .getBrowser () .getTexture2DUnit ();
 
-      if (this .skinCoordNode)
-         this .skinCoordNode ._point = this .skinBindingCoord ._point;
+      gl .activeTexture (gl .TEXTURE0 + jointsTextureTextureUnit);
+      gl .bindTexture (gl .TEXTURE_2D, this .jointsTexture);
+      gl .uniform1i (shaderObject .x3d_JointsTexture, jointsTextureTextureUnit);
+
+      gl .activeTexture (gl .TEXTURE0 + displacementsTextureTextureUnit);
+      gl .bindTexture (gl .TEXTURE_2D, this .displacementsTexture);
+      gl .uniform1i (shaderObject .x3d_DisplacementsTexture, displacementsTextureTextureUnit);
 
-      X3DChildNode .prototype .toJSONStream .call (this, generator);
+      gl .activeTexture (gl .TEXTURE0 + jointMatricesTextureUnit);
+      gl .bindTexture (gl .TEXTURE_2D, this .jointMatricesTexture);
+      gl .uniform1i (shaderObject .x3d_JointMatricesTexture, jointMatricesTextureUnit);
    },
    dispose ()
    {
@@ -421,6 +550,8 @@ Object .defineProperties (HAnimHumanoid,
          new X3DFieldDefinition (X3DConstants .inputOutput,    "description",           new Fields .SFString ()),
          new X3DFieldDefinition (X3DConstants .inputOutput,    "name",                  new Fields .SFString ()),
          new X3DFieldDefinition (X3DConstants .inputOutput,    "info",                  new Fields .MFString ()),
+         new X3DFieldDefinition (X3DConstants .inputOutput,    "skeletalConfiguration", new Fields .SFString ("BASIC")),
+         new X3DFieldDefinition (X3DConstants .inputOutput,    "loa",                   new Fields .SFInt32 (-1)),
          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)),
@@ -430,8 +561,6 @@ Object .defineProperties (HAnimHumanoid,
          new X3DFieldDefinition (X3DConstants .inputOutput,    "bboxDisplay",           new Fields .SFBool ()),
          new X3DFieldDefinition (X3DConstants .initializeOnly, "bboxSize",              new Fields .SFVec3f (-1, -1, -1)),
          new X3DFieldDefinition (X3DConstants .initializeOnly, "bboxCenter",            new Fields .SFVec3f ()),
-         new X3DFieldDefinition (X3DConstants .inputOutput,    "loa",                   new Fields .SFInt32 (-1)),
-         new X3DFieldDefinition (X3DConstants .inputOutput,    "skeletalConfiguration", new Fields .SFString ("BASIC")),
          new X3DFieldDefinition (X3DConstants .inputOutput,    "skeleton",              new Fields .MFNode ()),
          new X3DFieldDefinition (X3DConstants .inputOutput,    "viewpoints",            new Fields .MFNode ()),
          new X3DFieldDefinition (X3DConstants .inputOutput,    "sites",                 new Fields .MFNode ()),
@@ -452,4 +581,28 @@ Object .defineProperties (HAnimHumanoid,
    },
 });
 
+class Lock
+{
+   #locked = true;
+
+   enable ()
+   {
+      this .#locked = false;
+   }
+
+   lock ()
+   {
+      const locked = this .#locked;
+
+      this .#locked = true;
+
+      return locked;
+   }
+}
+
+function even (value)
+{
+   return value + value % 2;
+}
+
 export default HAnimHumanoid;