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

package/dist/dist.dev.js

@@ -122,7 +122,7 @@ var __exports__ = (() => {
   }
 
   // ../../node_modules/@loaders.gl/images/dist/lib/utils/version.js
-  var VERSION = true ? "4.3.2" : "latest";
+  var VERSION = true ? "4.4.0-alpha.18" : "latest";
 
   // ../../node_modules/@loaders.gl/images/dist/lib/category-api/image-type.js
   var parseImageNode = globalThis.loaders?.parseImageNode;
@@ -263,7 +263,6 @@ var __exports__ = (() => {
   }
 
   // ../../node_modules/@loaders.gl/images/dist/lib/parsers/parse-to-image-bitmap.js
-  var EMPTY_OBJECT = {};
   var imagebitmapOptionsSupported = true;
   async function parseToImageBitmap(arrayBuffer, options, url) {
     let blob;
@@ -291,8 +290,13 @@ var __exports__ = (() => {
     return await createImageBitmap(blob);
   }
   function isEmptyObject(object) {
-    for (const key in object || EMPTY_OBJECT) {
-      return false;
+    if (!object) {
+      return true;
+    }
+    for (const key in object) {
+      if (Object.prototype.hasOwnProperty.call(object, key)) {
+        return false;
+      }
     }
     return true;
   }
@@ -681,8 +685,8 @@ var __exports__ = (() => {
   }
 
   // src/parsers/parse-pbr-material.ts
-  var import_constants2 = __toESM(require_constants(), 1);
   var import_core = __toESM(require_core(), 1);
+  var import_constants2 = __toESM(require_constants(), 1);
 
   // src/webgl-to-webgpu/convert-webgl-sampler.ts
   var import_constants = __toESM(require_constants(), 1);
@@ -774,6 +778,8 @@ var __exports__ = (() => {
       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?.imageBasedLightingEnvironment)
@@ -873,12 +879,6 @@ var __exports__ = (() => {
   }
   function addTexture(device, gltfTexture, uniformName, define, parsedMaterial) {
     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.
@@ -890,16 +890,122 @@ var __exports__ = (() => {
       // default LINEAR filtering
       ...gltfTexture?.texture?.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) {
+    let levels;
+    if (Array.isArray(image.data) && image.data[0]?.data) {
+      levels = image.data;
+    } else if ("mipmaps" in image && Array.isArray(image.mipmaps)) {
+      levels = image.mipmaps;
+    } else {
+      levels = [];
+    }
+    if (levels.length === 0 || !levels[0]?.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;
+  }
 
   // ../../node_modules/@math.gl/core/dist/lib/common.js
   var RADIANS_TO_DEGREES = 1 / Math.PI * 180;
@@ -3474,17 +3580,20 @@ var __exports__ = (() => {
 
   // src/parsers/parse-gltf-lights.ts
   function parseGLTFLights(gltf) {
-    const lightDefs = gltf.extensions?.["KHR_lights_punctual"]?.["lights"];
+    const lightDefs = (
+      // `postProcessGLTF()` moves KHR_lights_punctual into `gltf.lights`.
+      gltf.lights || gltf.extensions?.["KHR_lights_punctual"]?.["lights"]
+    );
     if (!lightDefs || !Array.isArray(lightDefs) || lightDefs.length === 0) {
       return [];
     }
     const lights = [];
     for (const node of gltf.nodes || []) {
-      const nodeLight = node.extensions?.KHR_lights_punctual;
-      if (!nodeLight || typeof nodeLight.light !== "number") {
+      const lightIndex = node.light ?? node.extensions?.KHR_lights_punctual?.light;
+      if (typeof lightIndex !== "number") {
         continue;
       }
-      const gltfLight = lightDefs[nodeLight.light];
+      const gltfLight = lightDefs[lightIndex];
       if (!gltfLight) {
         continue;
       }
@@ -3508,7 +3617,7 @@ var __exports__ = (() => {
     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)];
@@ -3522,11 +3631,7 @@ var __exports__ = (() => {
     };
   }
   function parseDirectionalLight(node, color, intensity) {
-    let direction = [0, 0, -1];
-    if (node.rotation) {
-      const orientation = new Matrix4().fromQuaternion(node.rotation);
-      direction = orientation.transformDirection([0, 0, -1]);
-    }
+    const direction = getNodeDirection(node);
     return {
       type: "directional",
       direction,
@@ -3534,6 +3639,24 @@ var __exports__ = (() => {
       intensity
     };
   }
+  function getNodePosition(node) {
+    if (node.matrix) {
+      return new 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 Matrix4(node.matrix).transformDirection([0, 0, -1]);
+    }
+    if (node.rotation) {
+      return new Matrix4().fromQuaternion(node.rotation).transformDirection([0, 0, -1]);
+    }
+    return [0, 0, -1];
+  }
 
   // src/parsers/parse-gltf.ts
   var import_engine3 = __toESM(require_engine(), 1);
@@ -3563,50 +3686,88 @@ var __exports__ = (() => {
   var SHADER = (
     /* WGSL */
     `
-layout(0) positions: vec4; // in vec4 POSITION;
+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_NORMALS
-    in vec4 normals; // in vec4 NORMAL;
-  #endif
-
-  #ifdef HAS_TANGENTS
-    in vec4 TANGENT;
-  #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 = (
@@ -3630,6 +3791,11 @@ layout(0) positions: vec4; // in vec4 POSITION;
     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.);
@@ -3647,8 +3813,17 @@ layout(0) positions: vec4; // in vec4 POSITION;
       _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;
   }
 `
   );
@@ -3681,7 +3856,7 @@ layout(0) positions: vec4; // in vec4 POSITION;
       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 }
@@ -3705,69 +3880,73 @@ layout(0) positions: vec4; // in vec4 POSITION;
     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 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);
       }
-      const node = new import_engine3.GroupNode({
-        id: gltfNode.name || gltfNode.id,
+    });
+    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;
+      });
+      return new import_engine3.GroupNode({
+        id: gltfScene.name || gltfScene.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 Matrix4().fromQuaternion(gltfNode.rotation);
-          node.matrix.multiplyRight(rotationMatrix);
-        }
-        if (gltfNode.scale) {
-          node.matrix.scale(gltfNode.scale);
-        }
-      }
-      gltfNode._node = node;
-    }
-    const topLevelNode = gltfNodes.find((node) => node.id === gltfNode.id);
-    topLevelNode._node = gltfNode._node;
-    return gltfNode._node;
+    });
+    return { scenes, gltfMeshIdToNodeMap, gltfNodeIdToNodeMap, gltfNodeIndexToNodeMap };
+  }
+  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 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
-      });
-      gltfMesh._mesh = mesh;
-    }
-    return gltfMesh._mesh;
+  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 createPrimitive(device, gltfPrimitive, i, gltfMesh, options) {
+  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);
@@ -3806,31 +3985,28 @@ layout(0) positions: vec4; // in vec4 POSITION;
   }
 
   // src/gltf/gltf-animator.ts
-  var import_core7 = __toESM(require_core(), 1);
+  var import_core6 = __toESM(require_core(), 1);
 
   // src/gltf/animations/interpolate.ts
-  var import_core5 = __toESM(require_core(), 1);
-  var scratchQuaternion = new Quaternion();
+  var import_core4 = __toESM(require_core(), 1);
+  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) {
@@ -3840,13 +4016,7 @@ layout(0) positions: vec4; // in vec4 POSITION;
       case "LINEAR":
         if (nextTime > previousTime) {
           const ratio = (animationTime - previousTime) / (nextTime - previousTime);
-          linearInterpolate(
-            target,
-            path,
-            output[previousIndex],
-            output[nextIndex],
-            ratio
-          );
+          linearInterpolate(target, path, output[previousIndex], output[nextIndex], ratio);
         }
         break;
       case "CUBICSPLINE":
@@ -3861,23 +4031,19 @@ layout(0) positions: vec4; // in vec4 POSITION;
         }
         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 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, {
@@ -3888,83 +4054,80 @@ layout(0) positions: vec4; // in vec4 POSITION;
     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);
   }
 
   // src/gltf/gltf-animator.ts
   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 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);
-    }
-  }
 
   // src/webgl-to-webgpu/convert-webgl-attribute.ts
   var ATTRIBUTE_TYPE_TO_COMPONENTS = {
@@ -3996,65 +4159,79 @@ layout(0) positions: vec4; // in vec4 POSITION;
   // src/parsers/parse-gltf-animations.ts
   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])
+          output: accessorToJsArray2D(gltf.accessors[output], accessorCache2D)
         })
       );
-      const channels = animation.channels.map(({ sampler, target }) => ({
-        sampler: samplers[sampler],
-        target: gltf.nodes[target.node ?? 0],
-        path: target.path
-      }));
+      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);
+    assert3(components === 1, "accessorToJsArray1D must have exactly 1 component");
+    const result = Array.from(array);
+    accessorCache.set(accessor, result);
+    return result;
   }
-
-  // src/utils/deep-copy.ts
-  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);
+    assert3(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 assert3(condition, message) {
+    if (!condition) {
+      throw new Error(message);
     }
-    return object;
   }
 
   // src/gltf/create-scenegraph-from-gltf.ts
   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
+    };
   }
   return __toCommonJS(bundle_exports);
 })();