@luma.gl/gltf 9.3.0-alpha.4 → 9.3.0-alpha.6

package/dist/index.cjs

@@ -93,8 +93,8 @@ function makeCube(device, { id, getTextureForFace, sampler }) {
 }
 
 // dist/parsers/parse-pbr-material.js
-var import_constants2 = require("@luma.gl/constants");
 var import_core = require("@luma.gl/core");
+var import_constants2 = require("@luma.gl/constants");
 
 // dist/webgl-to-webgpu/convert-webgl-sampler.js
 var import_constants = require("@luma.gl/constants");
@@ -186,6 +186,8 @@ function parsePBRMaterial(device, material, attributes, options) {
     parsedMaterial.defines["HAS_TANGENTS"] = true;
   if (attributes["TEXCOORD_0"])
     parsedMaterial.defines["HAS_UV"] = true;
+  if (attributes["JOINTS_0"] && attributes["WEIGHTS_0"])
+    parsedMaterial.defines["HAS_SKIN"] = true;
   if (attributes["COLOR_0"])
     parsedMaterial.defines["HAS_COLORS"] = true;
   if (options == null ? void 0 : options.imageBasedLightingEnvironment)
@@ -256,12 +258,6 @@ function parsePbrMetallicRoughness(device, pbrMetallicRoughness, parsedMaterial)
 function addTexture(device, gltfTexture, uniformName, define, parsedMaterial) {
   var _a;
   const image = gltfTexture.texture.source.image;
-  let textureOptions;
-  if (image.compressed) {
-    textureOptions = image;
-  } else {
-    textureOptions = { data: image };
-  }
   const gltfSampler = {
     wrapS: 10497,
     // default REPEAT S (U) wrapping mode.
@@ -273,32 +269,136 @@ function addTexture(device, gltfTexture, uniformName, define, parsedMaterial) {
     // default LINEAR filtering
     ...(_a = gltfTexture == null ? void 0 : gltfTexture.texture) == null ? void 0 : _a.sampler
   };
-  const texture = device.createTexture({
+  const baseOptions = {
     id: gltfTexture.uniformName || gltfTexture.id,
-    sampler: convertSampler(gltfSampler),
-    ...textureOptions
-  });
+    sampler: convertSampler(gltfSampler)
+  };
+  let texture;
+  if (image.compressed) {
+    texture = createCompressedTexture(device, image, baseOptions);
+  } else {
+    const { width, height } = device.getExternalImageSize(image);
+    texture = device.createTexture({
+      ...baseOptions,
+      width,
+      height,
+      data: image
+    });
+  }
   parsedMaterial.bindings[uniformName] = texture;
   if (define)
     parsedMaterial.defines[define] = true;
   parsedMaterial.generatedTextures.push(texture);
 }
+function createCompressedTextureFallback(device, baseOptions) {
+  return device.createTexture({
+    ...baseOptions,
+    format: "rgba8unorm",
+    width: 1,
+    height: 1,
+    mipLevels: 1
+  });
+}
+function resolveCompressedTextureFormat(level) {
+  return level.textureFormat;
+}
+function getMaxCompressedMipLevels(baseWidth, baseHeight, format) {
+  const { blockWidth = 1, blockHeight = 1 } = import_core.textureFormatDecoder.getInfo(format);
+  let count = 1;
+  for (let i = 1; ; i++) {
+    const w = Math.max(1, baseWidth >> i);
+    const h = Math.max(1, baseHeight >> i);
+    if (w < blockWidth || h < blockHeight)
+      break;
+    count++;
+  }
+  return count;
+}
+function createCompressedTexture(device, image, baseOptions) {
+  var _a, _b;
+  let levels;
+  if (Array.isArray(image.data) && ((_a = image.data[0]) == null ? void 0 : _a.data)) {
+    levels = image.data;
+  } else if ("mipmaps" in image && Array.isArray(image.mipmaps)) {
+    levels = image.mipmaps;
+  } else {
+    levels = [];
+  }
+  if (levels.length === 0 || !((_b = levels[0]) == null ? void 0 : _b.data)) {
+    import_core.log.warn("createCompressedTexture: compressed image has no valid mip levels, creating fallback")();
+    return createCompressedTextureFallback(device, baseOptions);
+  }
+  const baseLevel = levels[0];
+  const baseWidth = baseLevel.width ?? image.width ?? 0;
+  const baseHeight = baseLevel.height ?? image.height ?? 0;
+  if (baseWidth <= 0 || baseHeight <= 0) {
+    import_core.log.warn("createCompressedTexture: base level has invalid dimensions, creating fallback")();
+    return createCompressedTextureFallback(device, baseOptions);
+  }
+  const format = resolveCompressedTextureFormat(baseLevel);
+  if (!format) {
+    import_core.log.warn("createCompressedTexture: compressed image has no textureFormat, creating fallback")();
+    return createCompressedTextureFallback(device, baseOptions);
+  }
+  const maxMipLevels = getMaxCompressedMipLevels(baseWidth, baseHeight, format);
+  const levelLimit = Math.min(levels.length, maxMipLevels);
+  let validLevelCount = 1;
+  for (let i = 1; i < levelLimit; i++) {
+    const level = levels[i];
+    if (!level.data || level.width <= 0 || level.height <= 0) {
+      import_core.log.warn(`createCompressedTexture: mip level ${i} has invalid data/dimensions, truncating`)();
+      break;
+    }
+    const levelFormat = resolveCompressedTextureFormat(level);
+    if (levelFormat && levelFormat !== format) {
+      import_core.log.warn(`createCompressedTexture: mip level ${i} format '${levelFormat}' differs from base '${format}', truncating`)();
+      break;
+    }
+    const expectedW = Math.max(1, baseWidth >> i);
+    const expectedH = Math.max(1, baseHeight >> i);
+    if (level.width !== expectedW || level.height !== expectedH) {
+      import_core.log.warn(`createCompressedTexture: mip level ${i} dimensions ${level.width}x${level.height} don't match expected ${expectedW}x${expectedH}, truncating`)();
+      break;
+    }
+    validLevelCount++;
+  }
+  const texture = device.createTexture({
+    ...baseOptions,
+    format,
+    usage: import_core.Texture.TEXTURE | import_core.Texture.COPY_DST,
+    width: baseWidth,
+    height: baseHeight,
+    mipLevels: validLevelCount,
+    data: baseLevel.data
+  });
+  for (let i = 1; i < validLevelCount; i++) {
+    texture.writeData(levels[i].data, {
+      width: levels[i].width,
+      height: levels[i].height,
+      mipLevel: i
+    });
+  }
+  return texture;
+}
 
 // dist/parsers/parse-gltf-lights.js
 var import_core2 = require("@math.gl/core");
 function parseGLTFLights(gltf) {
-  var _a, _b, _c;
-  const lightDefs = (_b = (_a = gltf.extensions) == null ? void 0 : _a["KHR_lights_punctual"]) == null ? void 0 : _b["lights"];
+  var _a, _b, _c, _d;
+  const lightDefs = (
+    // `postProcessGLTF()` moves KHR_lights_punctual into `gltf.lights`.
+    gltf.lights || ((_b = (_a = gltf.extensions) == null ? void 0 : _a["KHR_lights_punctual"]) == null ? void 0 : _b["lights"])
+  );
   if (!lightDefs || !Array.isArray(lightDefs) || lightDefs.length === 0) {
     return [];
   }
   const lights = [];
   for (const node of gltf.nodes || []) {
-    const nodeLight = (_c = node.extensions) == null ? void 0 : _c.KHR_lights_punctual;
-    if (!nodeLight || typeof nodeLight.light !== "number") {
+    const lightIndex = node.light ?? ((_d = (_c = node.extensions) == null ? void 0 : _c.KHR_lights_punctual) == null ? void 0 : _d.light);
+    if (typeof lightIndex !== "number") {
       continue;
     }
-    const gltfLight = lightDefs[nodeLight.light];
+    const gltfLight = lightDefs[lightIndex];
     if (!gltfLight) {
       continue;
     }
@@ -322,7 +422,7 @@ function parseGLTFLights(gltf) {
   return lights;
 }
 function parsePointLight(node, color, intensity, range) {
-  const position = node.translation ? [...node.translation] : [0, 0, 0];
+  const position = getNodePosition(node);
   let attenuation = [1, 0, 0];
   if (range !== void 0 && range > 0) {
     attenuation = [1, 0, 1 / (range * range)];
@@ -336,11 +436,7 @@ function parsePointLight(node, color, intensity, range) {
   };
 }
 function parseDirectionalLight(node, color, intensity) {
-  let direction = [0, 0, -1];
-  if (node.rotation) {
-    const orientation = new import_core2.Matrix4().fromQuaternion(node.rotation);
-    direction = orientation.transformDirection([0, 0, -1]);
-  }
+  const direction = getNodeDirection(node);
   return {
     type: "directional",
     direction,
@@ -348,10 +444,27 @@ function parseDirectionalLight(node, color, intensity) {
     intensity
   };
 }
+function getNodePosition(node) {
+  if (node.matrix) {
+    return new import_core2.Matrix4(node.matrix).transformAsPoint([0, 0, 0]);
+  }
+  if (node.translation) {
+    return [...node.translation];
+  }
+  return [0, 0, 0];
+}
+function getNodeDirection(node) {
+  if (node.matrix) {
+    return new import_core2.Matrix4(node.matrix).transformDirection([0, 0, -1]);
+  }
+  if (node.rotation) {
+    return new import_core2.Matrix4().fromQuaternion(node.rotation).transformDirection([0, 0, -1]);
+  }
+  return [0, 0, -1];
+}
 
 // dist/parsers/parse-gltf.js
 var import_engine3 = require("@luma.gl/engine");
-var import_core4 = require("@math.gl/core");
 
 // dist/webgl-to-webgpu/convert-webgl-topology.js
 var GLEnum;
@@ -388,50 +501,88 @@ var import_engine2 = require("@luma.gl/engine");
 var SHADER = (
   /* WGSL */
   `
-layout(0) positions: vec4; // in vec4 POSITION;
-
-  #ifdef HAS_NORMALS
-    in vec4 normals; // in vec4 NORMAL;
-  #endif
-
-  #ifdef HAS_TANGENTS
-    in vec4 TANGENT;
-  #endif
+struct VertexInputs {
+  @location(0) positions: vec3f,
+#ifdef HAS_NORMALS
+  @location(1) normals: vec3f,
+#endif
+#ifdef HAS_TANGENTS
+  @location(2) TANGENT: vec4f,
+#endif
+#ifdef HAS_UV
+  @location(3) texCoords: vec2f,
+#endif
+#ifdef HAS_SKIN
+  @location(4) JOINTS_0: vec4u,
+  @location(5) WEIGHTS_0: vec4f,
+#endif
+};
 
-  #ifdef HAS_UV
-    // in vec2 TEXCOORD_0;
-    in vec2 texCoords;
-  #endif
+struct FragmentInputs {
+  @builtin(position) position: vec4f,
+  @location(0) pbrPosition: vec3f,
+  @location(1) pbrUV: vec2f,
+  @location(2) pbrNormal: vec3f,
+#ifdef HAS_TANGENTS
+  @location(3) pbrTangent: vec4f,
+#endif
+};
 
 @vertex
-  void main(void) {
-    vec4 _NORMAL = vec4(0.);
-    vec4 _TANGENT = vec4(0.);
-    vec2 _TEXCOORD_0 = vec2(0.);
+fn vertexMain(inputs: VertexInputs) -> FragmentInputs {
+  var outputs: FragmentInputs;
+  var position = vec4f(inputs.positions, 1.0);
+  var normal = vec3f(0.0, 0.0, 1.0);
+  var tangent = vec4f(1.0, 0.0, 0.0, 1.0);
+  var uv = vec2f(0.0, 0.0);
 
-    #ifdef HAS_NORMALS
-      _NORMAL = normals;
-    #endif
+#ifdef HAS_NORMALS
+  normal = inputs.normals;
+#endif
+#ifdef HAS_UV
+  uv = inputs.texCoords;
+#endif
+#ifdef HAS_TANGENTS
+  tangent = inputs.TANGENT;
+#endif
+#ifdef HAS_SKIN
+  let skinMatrix = getSkinMatrix(inputs.WEIGHTS_0, inputs.JOINTS_0);
+  position = skinMatrix * position;
+  normal = normalize((skinMatrix * vec4f(normal, 0.0)).xyz);
+#ifdef HAS_TANGENTS
+  tangent = vec4f(normalize((skinMatrix * vec4f(tangent.xyz, 0.0)).xyz), tangent.w);
+#endif
+#endif
 
-    #ifdef HAS_TANGENTS
-      _TANGENT = TANGENT;
-    #endif
+  let worldPosition = pbrProjection.modelMatrix * position;
 
-    #ifdef HAS_UV
-      _TEXCOORD_0 = texCoords;
-    #endif
+#ifdef HAS_NORMALS
+  normal = normalize((pbrProjection.normalMatrix * vec4f(normal, 0.0)).xyz);
+#endif
+#ifdef HAS_TANGENTS
+  let worldTangent = normalize((pbrProjection.modelMatrix * vec4f(tangent.xyz, 0.0)).xyz);
+  outputs.pbrTangent = vec4f(worldTangent, tangent.w);
+#endif
 
-    pbr_setPositionNormalTangentUV(positions, _NORMAL, _TANGENT, _TEXCOORD_0);
-    gl_Position = u_MVPMatrix * positions;
-  }
+  outputs.position = pbrProjection.modelViewProjectionMatrix * position;
+  outputs.pbrPosition = worldPosition.xyz / worldPosition.w;
+  outputs.pbrUV = uv;
+  outputs.pbrNormal = normal;
+  return outputs;
+}
 
 @fragment
-  out vec4 fragmentColor;
-
-  void main(void) {
-    vec3 pos = pbr_vPosition;
-    fragmentColor = pbr_filterColor(vec4(1.0));
-  }
+fn fragmentMain(inputs: FragmentInputs) -> @location(0) vec4f {
+  fragmentInputs.pbr_vPosition = inputs.pbrPosition;
+  fragmentInputs.pbr_vUV = inputs.pbrUV;
+  fragmentInputs.pbr_vNormal = inputs.pbrNormal;
+#ifdef HAS_TANGENTS
+  let tangent = normalize(inputs.pbrTangent.xyz);
+  let bitangent = normalize(cross(inputs.pbrNormal, tangent)) * inputs.pbrTangent.w;
+  fragmentInputs.pbr_vTBN = mat3x3f(tangent, bitangent, inputs.pbrNormal);
+#endif
+  return pbr_filterColor(vec4f(1.0));
+}
 `
 );
 var vs = (
@@ -455,6 +606,11 @@ var vs = (
     in vec2 texCoords;
   #endif
 
+  #ifdef HAS_SKIN
+    in uvec4 JOINTS_0;
+    in vec4 WEIGHTS_0;
+  #endif
+
   void main(void) {
     vec4 _NORMAL = vec4(0.);
     vec4 _TANGENT = vec4(0.);
@@ -472,8 +628,17 @@ var vs = (
       _TEXCOORD_0 = texCoords;
     #endif
 
-    pbr_setPositionNormalTangentUV(positions, _NORMAL, _TANGENT, _TEXCOORD_0);
-    gl_Position = pbrProjection.modelViewProjectionMatrix * positions;
+    vec4 pos = positions;
+
+    #ifdef HAS_SKIN
+      mat4 skinMat = getSkinMatrix(WEIGHTS_0, JOINTS_0);
+      pos = skinMat * pos;
+      _NORMAL = skinMat * _NORMAL;
+      _TANGENT = vec4((skinMat * vec4(_TANGENT.xyz, 0.)).xyz, _TANGENT.w);
+    #endif
+
+    pbr_setPositionNormalTangentUV(pos, _NORMAL, _TANGENT, _TEXCOORD_0);
+    gl_Position = pbrProjection.modelViewProjectionMatrix * pos;
   }
 `
 );
@@ -506,7 +671,7 @@ function createGLTFModel(device, options) {
     geometry,
     topology: geometry.topology,
     vertexCount,
-    modules: [import_shadertools.pbrMaterial],
+    modules: [import_shadertools.pbrMaterial, import_shadertools.skin],
     ...modelOptions,
     defines: { ...parsedPPBRMaterial.defines, ...modelOptions.defines },
     parameters: { ...parameters, ...parsedPPBRMaterial.parameters, ...modelOptions.parameters }
@@ -530,65 +695,69 @@ var defaultOptions = {
   lights: true,
   useTangents: false
 };
-function parseGLTF(device, gltf, options_ = {}) {
-  const options = { ...defaultOptions, ...options_ };
-  const sceneNodes = gltf.scenes.map((gltfScene) => createScene(device, gltfScene, gltf.nodes, options));
-  return sceneNodes;
-}
-function createScene(device, gltfScene, gltfNodes, options) {
-  const gltfSceneNodes = gltfScene.nodes || [];
-  const nodes = gltfSceneNodes.map((node) => createNode(device, node, gltfNodes, options));
-  const sceneNode = new import_engine3.GroupNode({
-    id: gltfScene.name || gltfScene.id,
-    children: nodes
+function parseGLTF(device, gltf, options = {}) {
+  const combinedOptions = { ...defaultOptions, ...options };
+  const gltfMeshIdToNodeMap = /* @__PURE__ */ new Map();
+  gltf.meshes.forEach((gltfMesh, idx) => {
+    const newMesh = createNodeForGLTFMesh(device, gltfMesh, combinedOptions);
+    gltfMeshIdToNodeMap.set(gltfMesh.id, newMesh);
   });
-  return sceneNode;
-}
-function createNode(device, gltfNode, gltfNodes, options) {
-  if (!gltfNode._node) {
-    const gltfChildren = gltfNode.children || [];
-    const children = gltfChildren.map((child) => createNode(device, child, gltfNodes, options));
+  const gltfNodeIndexToNodeMap = /* @__PURE__ */ new Map();
+  const gltfNodeIdToNodeMap = /* @__PURE__ */ new Map();
+  gltf.nodes.forEach((gltfNode, idx) => {
+    const newNode = createNodeForGLTFNode(device, gltfNode, combinedOptions);
+    gltfNodeIndexToNodeMap.set(idx, newNode);
+    gltfNodeIdToNodeMap.set(gltfNode.id, newNode);
+  });
+  gltf.nodes.forEach((gltfNode, idx) => {
+    gltfNodeIndexToNodeMap.get(idx).add((gltfNode.children ?? []).map(({ id }) => {
+      const child = gltfNodeIdToNodeMap.get(id);
+      if (!child)
+        throw new Error(`Cannot find child ${id} of node ${idx}`);
+      return child;
+    }));
     if (gltfNode.mesh) {
-      children.push(createMesh(device, gltfNode.mesh, options));
-    }
-    const node = new import_engine3.GroupNode({
-      id: gltfNode.name || gltfNode.id,
-      children
-    });
-    if (gltfNode.matrix) {
-      node.setMatrix(gltfNode.matrix);
-    } else {
-      node.matrix.identity();
-      if (gltfNode.translation) {
-        node.matrix.translate(gltfNode.translation);
-      }
-      if (gltfNode.rotation) {
-        const rotationMatrix = new import_core4.Matrix4().fromQuaternion(gltfNode.rotation);
-        node.matrix.multiplyRight(rotationMatrix);
-      }
-      if (gltfNode.scale) {
-        node.matrix.scale(gltfNode.scale);
+      const mesh = gltfMeshIdToNodeMap.get(gltfNode.mesh.id);
+      if (!mesh) {
+        throw new Error(`Cannot find mesh child ${gltfNode.mesh.id} of node ${idx}`);
       }
+      gltfNodeIndexToNodeMap.get(idx).add(mesh);
     }
-    gltfNode._node = node;
-  }
-  const topLevelNode = gltfNodes.find((node) => node.id === gltfNode.id);
-  topLevelNode._node = gltfNode._node;
-  return gltfNode._node;
-}
-function createMesh(device, gltfMesh, options) {
-  if (!gltfMesh._mesh) {
-    const gltfPrimitives = gltfMesh.primitives || [];
-    const primitives = gltfPrimitives.map((gltfPrimitive, i) => createPrimitive(device, gltfPrimitive, i, gltfMesh, options));
-    const mesh = new import_engine3.GroupNode({
-      id: gltfMesh.name || gltfMesh.id,
-      children: primitives
+  });
+  const scenes = gltf.scenes.map((gltfScene) => {
+    const children = (gltfScene.nodes || []).map(({ id }) => {
+      const child = gltfNodeIdToNodeMap.get(id);
+      if (!child)
+        throw new Error(`Cannot find child ${id} of scene ${gltfScene.name || gltfScene.id}`);
+      return child;
     });
-    gltfMesh._mesh = mesh;
-  }
-  return gltfMesh._mesh;
+    return new import_engine3.GroupNode({
+      id: gltfScene.name || gltfScene.id,
+      children
+    });
+  });
+  return { scenes, gltfMeshIdToNodeMap, gltfNodeIdToNodeMap, gltfNodeIndexToNodeMap };
 }
-function createPrimitive(device, gltfPrimitive, i, gltfMesh, options) {
+function createNodeForGLTFNode(device, gltfNode, options) {
+  return new import_engine3.GroupNode({
+    id: gltfNode.name || gltfNode.id,
+    children: [],
+    matrix: gltfNode.matrix,
+    position: gltfNode.translation,
+    rotation: gltfNode.rotation,
+    scale: gltfNode.scale
+  });
+}
+function createNodeForGLTFMesh(device, gltfMesh, options) {
+  const gltfPrimitives = gltfMesh.primitives || [];
+  const primitives = gltfPrimitives.map((gltfPrimitive, i) => createNodeForGLTFPrimitive(device, gltfPrimitive, i, gltfMesh, options));
+  const mesh = new import_engine3.GroupNode({
+    id: gltfMesh.name || gltfMesh.id,
+    children: primitives
+  });
+  return mesh;
+}
+function createNodeForGLTFPrimitive(device, gltfPrimitive, i, gltfMesh, options) {
   const id = gltfPrimitive.name || `${gltfMesh.name || gltfMesh.id}-primitive-${i}`;
   const topology = convertGLDrawModeToTopology(gltfPrimitive.mode || 4);
   const vertexCount = gltfPrimitive.indices ? gltfPrimitive.indices.count : getVertexCount(gltfPrimitive.attributes);
@@ -622,33 +791,29 @@ function createGeometry(id, gltfPrimitive, topology) {
 }
 
 // dist/gltf/gltf-animator.js
-var import_core7 = require("@luma.gl/core");
-var import_core8 = require("@math.gl/core");
+var import_core6 = require("@luma.gl/core");
 
 // dist/gltf/animations/interpolate.js
-var import_core5 = require("@luma.gl/core");
-var import_core6 = require("@math.gl/core");
-var scratchQuaternion = new import_core6.Quaternion();
+var import_core4 = require("@luma.gl/core");
+var import_core5 = require("@math.gl/core");
+function updateTargetPath(target, path, newValue) {
+  switch (path) {
+    case "translation":
+      return target.setPosition(newValue).updateMatrix();
+    case "rotation":
+      return target.setRotation(newValue).updateMatrix();
+    case "scale":
+      return target.setScale(newValue).updateMatrix();
+    default:
+      import_core4.log.warn(`Bad animation path ${path}`)();
+      return null;
+  }
+}
 function interpolate(time, { input, interpolation, output }, target, path) {
   const maxTime = input[input.length - 1];
   const animationTime = time % maxTime;
   const nextIndex = input.findIndex((t) => t >= animationTime);
   const previousIndex = Math.max(0, nextIndex - 1);
-  if (!Array.isArray(target[path])) {
-    switch (path) {
-      case "translation":
-        target[path] = [0, 0, 0];
-        break;
-      case "rotation":
-        target[path] = [0, 0, 0, 1];
-        break;
-      case "scale":
-        target[path] = [1, 1, 1];
-        break;
-      default:
-        import_core5.log.warn(`Bad animation path ${path}`)();
-    }
-  }
   const previousTime = input[previousIndex];
   const nextTime = input[nextIndex];
   switch (interpolation) {
@@ -673,103 +838,96 @@ function interpolate(time, { input, interpolation, output }, target, path) {
       }
       break;
     default:
-      import_core5.log.warn(`Interpolation ${interpolation} not supported`)();
+      import_core4.log.warn(`Interpolation ${interpolation} not supported`)();
       break;
   }
 }
 function linearInterpolate(target, path, start, stop, ratio) {
-  if (!target[path]) {
-    throw new Error();
-  }
   if (path === "rotation") {
-    scratchQuaternion.slerp({ start, target: stop, ratio });
-    for (let i = 0; i < scratchQuaternion.length; i++) {
-      target[path][i] = scratchQuaternion[i];
-    }
+    updateTargetPath(target, path, new import_core5.Quaternion().slerp({ start, target: stop, ratio }));
   } else {
+    const newVal = [];
     for (let i = 0; i < start.length; i++) {
-      target[path][i] = ratio * stop[i] + (1 - ratio) * start[i];
+      newVal[i] = ratio * stop[i] + (1 - ratio) * start[i];
     }
+    updateTargetPath(target, path, newVal);
   }
 }
 function cubicsplineInterpolate(target, path, { p0, outTangent0, inTangent1, p1, tDiff, ratio: t }) {
-  if (!target[path]) {
-    throw new Error();
-  }
-  for (let i = 0; i < target[path].length; i++) {
+  const newVal = [];
+  for (let i = 0; i < p0.length; i++) {
     const m0 = outTangent0[i] * tDiff;
     const m1 = inTangent1[i] * tDiff;
-    target[path][i] = (2 * Math.pow(t, 3) - 3 * Math.pow(t, 2) + 1) * p0[i] + (Math.pow(t, 3) - 2 * Math.pow(t, 2) + t) * m0 + (-2 * Math.pow(t, 3) + 3 * Math.pow(t, 2)) * p1[i] + (Math.pow(t, 3) - Math.pow(t, 2)) * m1;
+    newVal[i] = (2 * Math.pow(t, 3) - 3 * Math.pow(t, 2) + 1) * p0[i] + (Math.pow(t, 3) - 2 * Math.pow(t, 2) + t) * m0 + (-2 * Math.pow(t, 3) + 3 * Math.pow(t, 2)) * p1[i] + (Math.pow(t, 3) - Math.pow(t, 2)) * m1;
   }
+  updateTargetPath(target, path, newVal);
 }
 function stepInterpolate(target, path, value) {
-  if (!target[path]) {
-    throw new Error();
-  }
-  for (let i = 0; i < value.length; i++) {
-    target[path][i] = value[i];
-  }
+  updateTargetPath(target, path, value);
 }
 
 // dist/gltf/gltf-animator.js
 var GLTFSingleAnimator = class {
+  /** Animation definition being played. */
   animation;
+  /** Target scenegraph lookup table. */
+  gltfNodeIdToNodeMap;
+  /** Playback start time in seconds. */
   startTime = 0;
+  /** Whether playback is currently enabled. */
   playing = true;
+  /** Playback speed multiplier. */
   speed = 1;
+  /** Creates a single-animation controller. */
   constructor(props) {
     this.animation = props.animation;
+    this.gltfNodeIdToNodeMap = props.gltfNodeIdToNodeMap;
     this.animation.name ||= "unnamed";
     Object.assign(this, props);
   }
+  /** Advances the animation to the supplied wall-clock time in milliseconds. */
   setTime(timeMs) {
     if (!this.playing) {
       return;
     }
     const absTime = timeMs / 1e3;
     const time = (absTime - this.startTime) * this.speed;
-    this.animation.channels.forEach(({ sampler, target, path }) => {
-      interpolate(time, sampler, target, path);
-      applyTranslationRotationScale(target, target._node);
+    this.animation.channels.forEach(({ sampler, targetNodeId, path }) => {
+      const targetNode = this.gltfNodeIdToNodeMap.get(targetNodeId);
+      if (!targetNode) {
+        throw new Error(`Cannot find animation target node ${targetNodeId}`);
+      }
+      interpolate(time, sampler, targetNode, path);
     });
   }
 };
 var GLTFAnimator = class {
+  /** Individual animation controllers. */
   animations;
+  /** Creates an animator for the supplied glTF scenegraph. */
   constructor(props) {
     this.animations = props.animations.map((animation, index) => {
       const name = animation.name || `Animation-${index}`;
       return new GLTFSingleAnimator({
+        gltfNodeIdToNodeMap: props.gltfNodeIdToNodeMap,
         animation: { name, channels: animation.channels }
       });
     });
   }
   /** @deprecated Use .setTime(). Will be removed (deck.gl is using this) */
   animate(time) {
-    import_core7.log.warn("GLTFAnimator#animate is deprecated. Use GLTFAnimator#setTime instead")();
+    import_core6.log.warn("GLTFAnimator#animate is deprecated. Use GLTFAnimator#setTime instead")();
     this.setTime(time);
   }
+  /** Advances every animation to the supplied wall-clock time in milliseconds. */
   setTime(time) {
     this.animations.forEach((animation) => animation.setTime(time));
   }
+  /** Returns the per-animation controllers managed by this animator. */
   getAnimations() {
     return this.animations;
   }
 };
-var scratchMatrix = new import_core8.Matrix4();
-function applyTranslationRotationScale(gltfNode, node) {
-  node.matrix.identity();
-  if (gltfNode.translation) {
-    node.matrix.translate(gltfNode.translation);
-  }
-  if (gltfNode.rotation) {
-    const rotationMatrix = scratchMatrix.fromQuaternion(gltfNode.rotation);
-    node.matrix.multiplyRight(rotationMatrix);
-  }
-  if (gltfNode.scale) {
-    node.matrix.scale(gltfNode.scale);
-  }
-}
 
 // dist/webgl-to-webgpu/convert-webgl-attribute.js
 var ATTRIBUTE_TYPE_TO_COMPONENTS = {
@@ -802,62 +960,72 @@ function accessorToTypedArray(accessor) {
 // dist/parsers/parse-gltf-animations.js
 function parseGLTFAnimations(gltf) {
   const gltfAnimations = gltf.animations || [];
+  const accessorCache1D = /* @__PURE__ */ new Map();
+  const accessorCache2D = /* @__PURE__ */ new Map();
   return gltfAnimations.map((animation, index) => {
     const name = animation.name || `Animation-${index}`;
     const samplers = animation.samplers.map(({ input, interpolation = "LINEAR", output }) => ({
-      input: accessorToJsArray(gltf.accessors[input]),
+      input: accessorToJsArray1D(gltf.accessors[input], accessorCache1D),
       interpolation,
-      output: accessorToJsArray(gltf.accessors[output])
-    }));
-    const channels = animation.channels.map(({ sampler, target }) => ({
-      sampler: samplers[sampler],
-      target: gltf.nodes[target.node ?? 0],
-      path: target.path
+      output: accessorToJsArray2D(gltf.accessors[output], accessorCache2D)
     }));
+    const channels = animation.channels.map(({ sampler, target }) => {
+      const targetNode = gltf.nodes[target.node ?? 0];
+      if (!targetNode) {
+        throw new Error(`Cannot find animation target ${target.node}`);
+      }
+      return {
+        sampler: samplers[sampler],
+        targetNodeId: targetNode.id,
+        path: target.path
+      };
+    });
     return { name, channels };
   });
 }
-function accessorToJsArray(accessor) {
-  if (!accessor._animation) {
-    const { typedArray: array, components } = accessorToTypedArray(accessor);
-    if (components === 1) {
-      accessor._animation = Array.from(array);
-    } else {
-      const slicedArray = [];
-      for (let i = 0; i < array.length; i += components) {
-        slicedArray.push(Array.from(array.slice(i, i + components)));
-      }
-      accessor._animation = slicedArray;
-    }
+function accessorToJsArray1D(accessor, accessorCache) {
+  if (accessorCache.has(accessor)) {
+    return accessorCache.get(accessor);
   }
-  return accessor._animation;
+  const { typedArray: array, components } = accessorToTypedArray(accessor);
+  assert(components === 1, "accessorToJsArray1D must have exactly 1 component");
+  const result = Array.from(array);
+  accessorCache.set(accessor, result);
+  return result;
 }
-
-// dist/utils/deep-copy.js
-function deepCopy(object) {
-  if (ArrayBuffer.isView(object) || object instanceof ArrayBuffer || object instanceof ImageBitmap) {
-    return object;
+function accessorToJsArray2D(accessor, accessorCache) {
+  if (accessorCache.has(accessor)) {
+    return accessorCache.get(accessor);
   }
-  if (Array.isArray(object)) {
-    return object.map(deepCopy);
+  const { typedArray: array, components } = accessorToTypedArray(accessor);
+  assert(components > 1, "accessorToJsArray2D must have more than 1 component");
+  const result = [];
+  for (let i = 0; i < array.length; i += components) {
+    result.push(Array.from(array.slice(i, i + components)));
   }
-  if (object && typeof object === "object") {
-    const result = {};
-    for (const key in object) {
-      result[key] = deepCopy(object[key]);
-    }
-    return result;
+  accessorCache.set(accessor, result);
+  return result;
+}
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message);
   }
-  return object;
 }
 
 // dist/gltf/create-scenegraph-from-gltf.js
 function createScenegraphsFromGLTF(device, gltf, options) {
-  gltf = deepCopy(gltf);
-  const scenes = parseGLTF(device, gltf, options);
+  const { scenes, gltfMeshIdToNodeMap, gltfNodeIdToNodeMap, gltfNodeIndexToNodeMap } = parseGLTF(device, gltf, options);
   const animations = parseGLTFAnimations(gltf);
-  const animator = new GLTFAnimator({ animations });
+  const animator = new GLTFAnimator({ animations, gltfNodeIdToNodeMap });
   const lights = parseGLTFLights(gltf);
-  return { scenes, animator, lights };
+  return {
+    scenes,
+    animator,
+    lights,
+    gltfMeshIdToNodeMap,
+    gltfNodeIdToNodeMap,
+    gltfNodeIndexToNodeMap,
+    gltf
+  };
 }
 //# sourceMappingURL=index.cjs.map