x_ite 8.8.7 → 8.9.1

package/src/x_ite/Parser/GLTF2Parser.js

@@ -88,6 +88,10 @@ function GLTF2Parser (scene)
    this .cameras               = [ ];
    this .viewpoints            = 0;
    this .nodes                 = [ ];
+   this .skins                 = [ ];
+   this .joints                = new Set ();
+   this .skeletons             = new Set ();
+   this .inverseBindMatrices   = new Map ();
    this .animations            = 0;
 }
 
@@ -130,10 +134,10 @@ Object .assign (Object .setPrototypeOf (GLTF2Parser .prototype, X3DParser .proto
          "meshes",
          "cameras",
          "nodes",
+         "skins",
          "scenes",
          "scene",
          "animations",
-         "skins",
       ]);
 
       return function ()
@@ -176,6 +180,9 @@ Object .assign (Object .setPrototypeOf (GLTF2Parser .prototype, X3DParser .proto
       scene .setEncoding ("GLTF");
       scene .setProfile (browser .getProfile ("Interchange"));
 
+      if (glTF .skins)
+         scene .addComponent (browser .getComponent ("HAnim"));
+
       // Parse root objects.
 
       this .assetObject      (glTF .asset);
@@ -200,9 +207,9 @@ Object .assign (Object .setPrototypeOf (GLTF2Parser .prototype, X3DParser .proto
       this .meshesArray     (glTF .meshes);
       this .camerasArray    (glTF .cameras);
       this .nodesArray      (glTF .nodes);
+      this .skinsArray      (glTF .skins);
       this .scenesArray     (glTF .scenes, glTF .scene);
       this .animationsArray (glTF .animations);
-      this .skinsArray      (glTF .skins);
 
       //this .optimizeSceneGraph (this .getExecutionContext () .getRootNodes ());
 
@@ -731,8 +738,7 @@ Object .assign (Object .setPrototypeOf (GLTF2Parser .prototype, X3DParser .proto
 
       const texCoordIndices = this .texCoordIndices ("", material);
 
-      this .texCoordIndex = [... texCoordIndices] .reduce (Math .max, -1);
-
+      this .texCoordIndex         = [... texCoordIndices] .reduce (Math .max, -1);
       this .textureTransformNodes = [ ];
       this .texCoordMappings      = new Map ();
       material .texCoordMappings  = this .texCoordMappings;
@@ -1028,7 +1034,7 @@ Object .assign (Object .setPrototypeOf (GLTF2Parser .prototype, X3DParser .proto
 
       this .meshes = meshes;
    },
-   meshObject (mesh)
+   meshObject (mesh, skin)
    {
       if (!(mesh instanceof Object))
          return;
@@ -1036,7 +1042,16 @@ Object .assign (Object .setPrototypeOf (GLTF2Parser .prototype, X3DParser .proto
       if (mesh .shapeNodes)
          return mesh .shapeNodes;
 
-      const shapeNodes = this .primitivesArray (mesh .primitives);
+      if (skin instanceof Object)
+      {
+         const scene = this .getScene ();
+
+         skin .textureCoordinateNode = scene .createNode ("TextureCoordinate", false);
+         skin .normalNode            = scene .createNode ("Normal", false);
+         skin .coordinateNode        = scene .createNode ("Coordinate", false);
+      }
+
+      const shapeNodes = this .primitivesArray (mesh .primitives, skin);
 
       // Name Shape nodes.
 
@@ -1053,9 +1068,16 @@ Object .assign (Object .setPrototypeOf (GLTF2Parser .prototype, X3DParser .proto
          }
       }
 
+      if (skin instanceof Object)
+      {
+         skin .textureCoordinateNode .setup ();
+         skin .normalNode            .setup ();
+         skin .coordinateNode        .setup ();
+      }
+
       return mesh .shapeNodes = shapeNodes;
    },
-   primitivesArray (primitives)
+   primitivesArray (primitives, skin)
    {
       if (!(primitives instanceof Array))
          return [ ];
@@ -1063,11 +1085,11 @@ Object .assign (Object .setPrototypeOf (GLTF2Parser .prototype, X3DParser .proto
       const shapeNodes = [ ];
 
       for (const primitive of primitives)
-         this .primitiveObject (primitive, shapeNodes);
+         this .primitiveObject (primitive, skin, shapeNodes);
 
       return shapeNodes;
    },
-   primitiveObject (primitive, shapeNodes)
+   primitiveObject (primitive, skin, shapeNodes)
    {
       if (!(primitive instanceof Object))
          return;
@@ -1080,7 +1102,7 @@ Object .assign (Object .setPrototypeOf (GLTF2Parser .prototype, X3DParser .proto
 
       this .primitiveExtensionsObject (primitive .extensions, primitive)
 
-      shapeNodes .push (this .createShape (primitive));
+      shapeNodes .push (this .createShape (primitive, skin));
    },
    attributesObject (attributes)
    {
@@ -1365,7 +1387,7 @@ Object .assign (Object .setPrototypeOf (GLTF2Parser .prototype, X3DParser .proto
 
       this .nodes = nodes;
    },
-   nodeObject (node)
+   nodeObject (node, index)
    {
       if (!(node instanceof Object))
          return;
@@ -1377,7 +1399,8 @@ Object .assign (Object .setPrototypeOf (GLTF2Parser .prototype, X3DParser .proto
 
       const
          scene         = this .getExecutionContext (),
-         transformNode = scene .createNode ("Transform", false),
+         typeName      = this .joints .has (index) ? "HAnimJoint" : "Transform",
+         transformNode = scene .createNode (typeName, false),
          name          = this .sanitizeName (node .name);
 
       // Name
@@ -1386,6 +1409,9 @@ Object .assign (Object .setPrototypeOf (GLTF2Parser .prototype, X3DParser .proto
       {
          scene .addNamedNode (scene .getUniqueName (name), transformNode);
          scene .addExportedNode (scene .getUniqueExportName (name), transformNode);
+
+         if (typeName === "HAnimJoint")
+            transformNode ._name = node .name;
       }
 
       // Set transformation matrix.
@@ -1435,7 +1461,52 @@ Object .assign (Object .setPrototypeOf (GLTF2Parser .prototype, X3DParser .proto
       const mesh = this .meshes [node .mesh];
 
       if (mesh)
-         transformNode ._children .push (... this .meshObject (mesh));
+      {
+         const
+            skin       = this .skins [node .skin],
+            shapeNodes = this .meshObject (mesh, skin);
+
+         transformNode ._children .push (... shapeNodes);
+
+         if (skin && shapeNodes .length)
+         {
+            var humanoidNode = scene .createNode ("HAnimHumanoid", false);
+
+            const name = this .sanitizeName (skin .name);
+
+            if (name)
+               scene .addNamedNode (scene .getUniqueName (name), humanoidNode);
+
+            humanoidNode ._name                  = skin .name;
+            humanoidNode ._version               = "2.0";
+            humanoidNode ._skeletalConfiguration = "NONE";
+
+            const skeletonNode = this .nodeObject (this .nodes [skin .skeleton], skin .skeleton);
+
+            if (skeletonNode)
+               humanoidNode ._skeleton .push (skeletonNode);
+
+            for (const joint of skin .joints)
+            {
+               const inverseBindMatrix = this .inverseBindMatrices .get (joint);
+
+               inverseBindMatrix .get (translation, rotation, scale);
+
+               humanoidNode ._joints .push (this .nodeObject (this .nodes [joint], joint));
+               humanoidNode ._jointBindingPositions .push (translation);
+               humanoidNode ._jointBindingRotations .push (rotation);
+               humanoidNode ._jointBindingScales .push (scale);
+            }
+
+            humanoidNode ._skinBindingNormal = shapeNodes [0] ._geometry .normal ?.getValue () ?.copy ();
+            humanoidNode ._skinBindingCoord  = shapeNodes [0] ._geometry .coord ?.getValue () ?.copy ();
+            humanoidNode ._skinNormal        = shapeNodes [0] ._geometry .normal;
+            humanoidNode ._skinCoord         = shapeNodes [0] ._geometry .coord;
+            humanoidNode ._skin .push (transformNode);
+
+            humanoidNode .setup ();
+         }
+      }
 
       // Get children.
 
@@ -1445,10 +1516,13 @@ Object .assign (Object .setPrototypeOf (GLTF2Parser .prototype, X3DParser .proto
 
       transformNode .setup ();
 
-      if (transformNode ._children .length === 0)
-         return node .childNode = null;
+      if (typeName === "Transform")
+      {
+         if (!transformNode ._children .length)
+            return node .childNode = null;
+      }
 
-      return node .childNode = transformNode;
+      return node .childNode = humanoidNode ?? transformNode;
    },
    nodeExtensions (extensions, transformNode)
    {
@@ -1477,9 +1551,68 @@ Object .assign (Object .setPrototypeOf (GLTF2Parser .prototype, X3DParser .proto
          return [ ];
 
       return children
+         .filter (index => !this .skeletons .has (index))
          .map (index => this .nodeObject (this .nodes [index], index))
          .filter (node => node);
    },
+   skinsArray (skins)
+   {
+      if (!(skins instanceof Array))
+         return;
+
+      this .skins = skins;
+
+      for (const skin of skins)
+         this .skinObject (skin);
+   },
+   skinObject: function (skin)
+   {
+      if (!(skin instanceof Object))
+         return;
+
+      skin .joints = this .jointsArray (skin .joints);
+
+      if (skin .skeleton === undefined)
+         skin .skeleton = this .skeleton (skin .joints);
+
+      this .skeletons .add (skin .skeleton);
+
+      this .inverseBindMatricesAccessors (this .accessors [skin .inverseBindMatrices], skin .joints);
+   },
+   jointsArray: function (joints)
+   {
+      if (!(joints instanceof Array))
+         return [ ];
+
+      joints .forEach (index => this .joints .add (index));
+
+      return joints;
+   },
+   skeleton: function (joints)
+   {
+      const children = new Set (joints
+         .map (index => this .nodes [index])
+         .filter (node => node instanceof Object)
+         .filter (node => node .children instanceof Array)
+         .flatMap (node => node .children));
+
+      return joints .filter (index => !children .has (index)) [0];
+   },
+   inverseBindMatricesAccessors: function (inverseBindMatrices, joints)
+   {
+      if (!inverseBindMatrices)
+         return;
+
+      const
+         array    = inverseBindMatrices .array,
+         length   = array .length,
+         matrices = [ ];
+
+      for (let i = 0; i < length; i += 16)
+         matrices .push (new Matrix4 (... array .subarray (i, i + 16)));
+
+      matrices .forEach ((matrix, i) => this .inverseBindMatrices .set (joints [i], matrix));
+   },
    scenesArray (scenes, sceneNumber)
    {
       if (!(scenes instanceof Array))
@@ -1641,7 +1774,7 @@ Object .assign (Object .setPrototypeOf (GLTF2Parser .prototype, X3DParser .proto
 
       const cycleInterval = samplers
          .map (sampler => this .accessors [sampler .input])
-         .filter (input => input && input .array .length)
+         .filter (input => input ?.array .length)
          .reduce ((value, input) => Math .max (value, input .array .at (-1)), 0);
 
       timeSensorNode ._loop          = DEVELOPMENT;
@@ -1661,7 +1794,7 @@ Object .assign (Object .setPrototypeOf (GLTF2Parser .prototype, X3DParser .proto
       if (!(target instanceof Object))
          return null;
 
-      const node = this .nodeObject (this .nodes [target .node]);
+      const node = this .nodeObject (this .nodes [target .node], target .node);
 
       if (!node)
          return null;
@@ -1699,11 +1832,6 @@ Object .assign (Object .setPrototypeOf (GLTF2Parser .prototype, X3DParser .proto
 
       return interpolatorNode;
    },
-   skinsArray (skins)
-   {
-      if (!(skins instanceof Array))
-         return;
-   },
    createNavigationInfo ()
    {
       const
@@ -1716,13 +1844,13 @@ Object .assign (Object .setPrototypeOf (GLTF2Parser .prototype, X3DParser .proto
 
       return navigationInfoNode;
    },
-   createShape (primitive)
+   createShape (primitive, skin)
    {
       const
          scene          = this .getExecutionContext (),
          shapeNode      = scene .createNode ("Shape", false),
          appearanceNode = this .materialObject (primitive .material),
-         geometryNode   = this .createGeometry (primitive);
+         geometryNode   = this .createGeometry (primitive, skin);
 
       shapeNode ._appearance = appearanceNode;
       shapeNode ._geometry   = geometryNode;
@@ -1795,54 +1923,54 @@ Object .assign (Object .setPrototypeOf (GLTF2Parser .prototype, X3DParser .proto
          }
       }
    },
-   createGeometry (primitive)
+   createGeometry (primitive, skin)
    {
       switch (primitive .mode)
       {
          case 0: // POINTS
          {
-            return this .createPointSet (primitive);
+            return this .createPointSet (primitive, skin);
          }
          case 1: // LINES
          {
             if (primitive .indices)
-               return this .createIndexedLineSet (primitive, 1);
+               return this .createIndexedLineSet (primitive, skin, 1);
 
-            return this .createLineSet (primitive);
+            return this .createLineSet (primitive, skin);
          }
          case 2: // LINE_LOOP
          {
-            return this .createIndexedLineSet (primitive, 2);
+            return this .createIndexedLineSet (primitive, skin, 2);
          }
          case 3: // LINE_STRIP
          {
-            return this .createIndexedLineSet (primitive, 3);
+            return this .createIndexedLineSet (primitive, skin, 3);
          }
          default:
          case 4: // TRIANGLES
          {
             if (primitive .indices)
-               return this .createIndexedTriangleSet (primitive);
+               return this .createIndexedTriangleSet (primitive, skin);
 
-            return this .createTriangleSet (primitive);
+            return this .createTriangleSet (primitive, skin);
          }
          case 5: // TRIANGLE_STRIP
          {
             if (primitive .indices)
-               return this .createIndexedTriangleStripSet (primitive);
+               return this .createIndexedTriangleStripSet (primitive, skin);
 
-            return this .createTriangleStripSet (primitive);
+            return this .createTriangleStripSet (primitive, skin);
          }
          case 6: // TRIANGLE_FAN
          {
             if (primitive .indices)
-               return this .createIndexedTriangleFanSet (primitive);
+               return this .createIndexedTriangleFanSet (primitive, skin);
 
-            return this .createTriangleFanSet (primitive);
+            return this .createTriangleFanSet (primitive, skin);
          }
       }
    },
-   createPointSet ({ attributes, material })
+   createPointSet ({ attributes, material }, skin)
    {
       const
          scene        = this .getExecutionContext (),
@@ -1852,11 +1980,14 @@ Object .assign (Object .setPrototypeOf (GLTF2Parser .prototype, X3DParser .proto
       geometryNode ._normal = this .createNormal (attributes .NORMAL);
       geometryNode ._coord  = this .createCoordinate (attributes .POSITION);
 
+      this .attributesJointsArray (skin, attributes .JOINTS, attributes .WEIGHTS);
+      this .skinGeometry (skin, geometryNode);
+
       geometryNode .setup ();
 
       return geometryNode;
    },
-   createIndexedLineSet ({ attributes, indices, material }, mode)
+   createIndexedLineSet ({ attributes, indices, material }, skin, mode)
    {
       const
          scene        = this .getExecutionContext (),
@@ -1878,7 +2009,7 @@ Object .assign (Object .setPrototypeOf (GLTF2Parser .prototype, X3DParser .proto
             for (let i = 0; i < length; i += 2)
                coordIndex .push (array [i], array [i + 1], -1);
 
-            break
+            break;
          }
          case 2: // LINE_LOOP
          {
@@ -1886,7 +2017,8 @@ Object .assign (Object .setPrototypeOf (GLTF2Parser .prototype, X3DParser .proto
 
             if (indices)
             {
-               coordIndex .push (... indices .array);
+               for (const i of indices .array)
+                  coordIndex .push (i);
 
                if (coordIndex .length)
                   coordIndex .push (coordIndex [0], -1);
@@ -1895,10 +2027,16 @@ Object .assign (Object .setPrototypeOf (GLTF2Parser .prototype, X3DParser .proto
             {
                const coord = geometryNode ._coord;
 
-               if (coord && coord .point .length)
-                  coordIndex .push (... coord .point .keys (), 0, -1);
+               if (coord ?.point .length)
+               {
+                  for (const i of coord .point .keys ())
+                     coordIndex .push (i);
+
+                  coordIndex .push (0, -1);
+               }
             }
-            break
+
+            break;
          }
          case 3: // LINE_STRIP
          {
@@ -1906,7 +2044,8 @@ Object .assign (Object .setPrototypeOf (GLTF2Parser .prototype, X3DParser .proto
 
             if (indices)
             {
-               coordIndex .push (... indices .array);
+               for (const i of indices .array)
+                  coordIndex .push (i);
 
                if (coordIndex .length)
                   coordIndex .push (-1);
@@ -1915,19 +2054,27 @@ Object .assign (Object .setPrototypeOf (GLTF2Parser .prototype, X3DParser .proto
             {
                const coord = geometryNode ._coord;
 
-               if (coord && coord .point .length)
-                  coordIndex .push (... coord .point .keys (), -1);
+               if (coord ?.point .length)
+               {
+                  for (const i of coord .point .keys ())
+                     coordIndex .push (i);
+
+                  coordIndex .push (-1);
+               }
             }
 
-            break
+            break;
          }
       }
 
+      this .attributesJointsArray (skin, attributes .JOINTS, attributes .WEIGHTS);
+      this .skinGeometry (skin, geometryNode);
+
       geometryNode .setup ();
 
       return geometryNode;
    },
-   createLineSet ({ attributes, material })
+   createLineSet ({ attributes, material }, skin)
    {
       const
          scene        = this .getExecutionContext (),
@@ -1937,11 +2084,14 @@ Object .assign (Object .setPrototypeOf (GLTF2Parser .prototype, X3DParser .proto
       geometryNode ._normal = this .createNormal (attributes .NORMAL);
       geometryNode ._coord  = this .createCoordinate (attributes .POSITION);
 
+      this .attributesJointsArray (skin, attributes .JOINTS, attributes .WEIGHTS);
+      this .skinGeometry (skin, geometryNode);
+
       geometryNode .setup ();
 
       return geometryNode;
    },
-   createIndexedTriangleSet ({ attributes, indices, material })
+   createIndexedTriangleSet ({ attributes, indices, material }, skin)
    {
       const
          scene        = this .getExecutionContext (),
@@ -1955,11 +2105,14 @@ Object .assign (Object .setPrototypeOf (GLTF2Parser .prototype, X3DParser .proto
       geometryNode ._coord           = this .createCoordinate (attributes .POSITION);
       geometryNode ._normalPerVertex = !! geometryNode ._normal;
 
+      this .attributesJointsArray (skin, attributes .JOINTS, attributes .WEIGHTS);
+      this .skinGeometry (skin, geometryNode);
+
       geometryNode .setup ();
 
       return geometryNode;
    },
-   createTriangleSet ({ attributes, material })
+   createTriangleSet ({ attributes, material }, skin)
    {
       const
          scene        = this .getExecutionContext (),
@@ -1972,11 +2125,14 @@ Object .assign (Object .setPrototypeOf (GLTF2Parser .prototype, X3DParser .proto
       geometryNode ._coord           = this .createCoordinate (attributes .POSITION);
       geometryNode ._normalPerVertex = !! geometryNode ._normal;
 
+      this .attributesJointsArray (skin, attributes .JOINTS, attributes .WEIGHTS);
+      this .skinGeometry (skin, geometryNode);
+
       geometryNode .setup ();
 
       return geometryNode;
    },
-   createIndexedTriangleStripSet ({ attributes, indices, material })
+   createIndexedTriangleStripSet ({ attributes, indices, material }, skin)
    {
       const
          scene        = this .getExecutionContext (),
@@ -1990,11 +2146,14 @@ Object .assign (Object .setPrototypeOf (GLTF2Parser .prototype, X3DParser .proto
       geometryNode ._coord           = this .createCoordinate (attributes .POSITION);
       geometryNode ._normalPerVertex = !! geometryNode ._normal;
 
+      this .attributesJointsArray (skin, attributes .JOINTS, attributes .WEIGHTS);
+      this .skinGeometry (skin, geometryNode);
+
       geometryNode .setup ();
 
       return geometryNode;
    },
-   createTriangleStripSet ({ attributes, material })
+   createTriangleStripSet ({ attributes, material }, skin)
    {
       const
          scene        = this .getExecutionContext (),
@@ -2015,11 +2174,14 @@ Object .assign (Object .setPrototypeOf (GLTF2Parser .prototype, X3DParser .proto
             geometryNode ._stripCount = [coord .point .length];
       }
 
+      this .attributesJointsArray (skin, attributes .JOINTS, attributes .WEIGHTS);
+      this .skinGeometry (skin, geometryNode);
+
       geometryNode .setup ();
 
       return geometryNode;
    },
-   createIndexedTriangleFanSet ({ attributes, indices, material })
+   createIndexedTriangleFanSet ({ attributes, indices, material }, skin)
    {
       const
          scene        = this .getExecutionContext (),
@@ -2033,11 +2195,14 @@ Object .assign (Object .setPrototypeOf (GLTF2Parser .prototype, X3DParser .proto
       geometryNode ._coord           = this .createCoordinate (attributes .POSITION);
       geometryNode ._normalPerVertex = !! geometryNode ._normal;
 
+      this .attributesJointsArray (skin, attributes .JOINTS, attributes .WEIGHTS);
+      this .skinGeometry (skin, geometryNode);
+
       geometryNode .setup ();
 
       return geometryNode;
    },
-   createTriangleFanSet ({ attributes, material })
+   createTriangleFanSet ({ attributes, material }, skin)
    {
       const
          scene        = this .getExecutionContext (),
@@ -2058,6 +2223,9 @@ Object .assign (Object .setPrototypeOf (GLTF2Parser .prototype, X3DParser .proto
             geometryNode ._fanCount = [coord .point .length];
       }
 
+      this .attributesJointsArray (skin, attributes .JOINTS, attributes .WEIGHTS);
+      this .skinGeometry (skin, geometryNode);
+
       geometryNode .setup ();
 
       return geometryNode;
@@ -2204,6 +2372,99 @@ Object .assign (Object .setPrototypeOf (GLTF2Parser .prototype, X3DParser .proto
 
       return position .coordinateNode = coordinateNode;
    },
+   attributesJointsArray: function (skin, joints, weights)
+   {
+      if (!(skin instanceof Object))
+         return;
+
+      if (!(joints instanceof Array))
+         return;
+
+      if (!(weights instanceof Array))
+         return;
+
+      for (let i = 0, length = joints .length; i < length; ++ i)
+         this .attributesJointsObject (skin, joints [i], weights [i]);
+   },
+   attributesJointsObject: function (skin, joints, weights)
+   {
+      if (!(joints instanceof Object))
+         return;
+
+      if (!(weights instanceof Object))
+         return;
+
+      if (joints .type !== "VEC4")
+         return;
+
+      if (weights .type !== "VEC4")
+         return;
+
+      const
+         start        = skin .coordinateNode ._point .length,
+         jointsArray  = joints .array,
+         weightsArray = weights .array,
+         numVertices  = jointsArray .length / 4;
+
+      for (let v = 0; v < numVertices; ++ v)
+      {
+         for (let i = 0; i < 4; ++ i)
+         {
+            const w = weightsArray [v * 4 + i];
+
+            if (w === 0)
+               continue;
+
+            const
+               index     = skin .joints [jointsArray [v * 4 + i]],
+               jointNode = this .nodeObject (this .nodes [index], index);
+
+            jointNode ._skinCoordIndex  .push (v + start);
+            jointNode ._skinCoordWeight .push (w);
+         }
+      }
+   },
+   skinGeometry: function (skin, geometryNode)
+   {
+      if (!(skin instanceof Object))
+         return;
+
+      const
+         skinTextureCoordinateNode = skin .textureCoordinateNode,
+         skinNormalNode            = skin .normalNode,
+         skinCoordinateNode        = skin .coordinateNode,
+         start                     = skinCoordinateNode ._point .length,
+         textureCoordinateNode     = geometryNode ._texCoord ?.getValue (),
+         normalNode                = geometryNode ._normal ?.getValue (),
+         coordinateNode            = geometryNode ._coord ?.getValue ();
+
+      if (geometryNode ._coordIndex)
+         geometryNode ._coordIndex = geometryNode ._coordIndex .map (index => index < 0 ? -1 : index + start);
+
+      if (geometryNode ._index)
+         geometryNode ._index = geometryNode ._index .map (index => index < 0 ? -1 : index + start);
+
+      if (textureCoordinateNode)
+      {
+         const point = skinTextureCoordinateNode ._point;
+         textureCoordinateNode ._point .forEach ((p, i) => point [i + start] = p);
+         geometryNode ._texCoord = skinTextureCoordinateNode;
+      }
+
+      if (normalNode)
+      {
+         const vector = skinNormalNode ._vector;
+         normalNode ._vector .forEach ((v, i) => vector [i + start] = v);
+         geometryNode ._normal = skinNormalNode;
+      }
+
+      if (coordinateNode)
+      {
+         const point = skinCoordinateNode ._point;
+         coordinateNode ._point .forEach ((p, i) => point [i + start] = p);
+         geometryNode ._coord = skinCoordinateNode;
+      }
+   },
    createInterpolator (path, interpolation, times, keyValues, cycleInterval)
    {
       const scene = this .getExecutionContext ();