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

package/dist/dist.dev.js

@@ -52,13 +52,6 @@ var __exports__ = (() => {
     }
   });
 
-  // external-global-plugin:@luma.gl/constants
-  var require_constants = __commonJS({
-    "external-global-plugin:@luma.gl/constants"(exports, module) {
-      module.exports = globalThis.luma;
-    }
-  });
-
   // external-global-plugin:@luma.gl/shadertools
   var require_shadertools = __commonJS({
     "external-global-plugin:@luma.gl/shadertools"(exports, module) {
@@ -71,6 +64,7 @@ var __exports__ = (() => {
   __export(bundle_exports, {
     GLTFAnimator: () => GLTFAnimator,
     createScenegraphsFromGLTF: () => createScenegraphsFromGLTF,
+    getGLTFExtensionSupport: () => getGLTFExtensionSupport,
     loadPBREnvironment: () => loadPBREnvironment,
     parseGLTFLights: () => parseGLTFLights,
     parsePBRMaterial: () => parsePBRMaterial
@@ -122,7 +116,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 +257,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 +284,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;
   }
@@ -616,6 +614,7 @@ var __exports__ = (() => {
 
   // src/pbr/pbr-environment.ts
   function loadPBREnvironment(device, props) {
+    const specularMipLevels = props.specularMipLevels ?? 1;
     const brdfLutTexture = new import_engine.DynamicTexture(device, {
       id: "brdfLUT",
       sampler: {
@@ -629,7 +628,9 @@ var __exports__ = (() => {
     });
     const diffuseEnvSampler = makeCube(device, {
       id: "DiffuseEnvSampler",
-      getTextureForFace: (dir) => loadImageTexture(props.getTexUrl("diffuse", dir, 0)),
+      getTextureForFace: (face) => loadImageTexture(
+        props.getTexUrl("diffuse", FACES.indexOf(face), 0)
+      ),
       sampler: {
         addressModeU: "clamp-to-edge",
         addressModeV: "clamp-to-edge",
@@ -639,12 +640,13 @@ var __exports__ = (() => {
     });
     const specularEnvSampler = makeCube(device, {
       id: "SpecularEnvSampler",
-      getTextureForFace: (dir) => {
+      getTextureForFace: (face) => {
         const imageArray = [];
-        for (let lod = 0; lod <= props.specularMipLevels - 1; lod++) {
-          imageArray.push(loadImageTexture(props.getTexUrl("specular", dir, lod)));
+        const direction = FACES.indexOf(face);
+        for (let lod = 0; lod < specularMipLevels; lod++) {
+          imageArray.push(loadImageTexture(props.getTexUrl("specular", direction, lod)));
         }
-        return imageArray;
+        return Promise.all(imageArray);
       },
       sampler: {
         addressModeU: "clamp-to-edge",
@@ -660,32 +662,34 @@ var __exports__ = (() => {
       specularEnvSampler
     };
   }
-  var FACES = [0, 1, 2, 3, 4, 5];
+  var FACES = ["+X", "-X", "+Y", "-Y", "+Z", "-Z"];
   function makeCube(device, {
     id,
     getTextureForFace,
     sampler
   }) {
-    const data = {};
-    FACES.forEach((face) => {
-      data[String(face)] = getTextureForFace(face);
+    const data = Promise.all(
+      FACES.map((face) => getTextureForFace(face))
+    ).then((faceDataArray) => {
+      const cubeData = {};
+      FACES.forEach((face, index) => {
+        cubeData[face] = faceDataArray[index];
+      });
+      return cubeData;
     });
     return new import_engine.DynamicTexture(device, {
       id,
       dimension: "cube",
       mipmaps: false,
       sampler,
-      // @ts-expect-error
       data
     });
   }
 
   // src/parsers/parse-pbr-material.ts
-  var import_constants2 = __toESM(require_constants(), 1);
   var import_core = __toESM(require_core(), 1);
 
   // src/webgl-to-webgpu/convert-webgl-sampler.ts
-  var import_constants = __toESM(require_constants(), 1);
   function convertSampler(gltfSampler) {
     return {
       addressModeU: convertSamplerWrapMode(gltfSampler.wrapS),
@@ -696,11 +700,11 @@ var __exports__ = (() => {
   }
   function convertSamplerWrapMode(mode) {
     switch (mode) {
-      case import_constants.GL.CLAMP_TO_EDGE:
+      case 33071 /* CLAMP_TO_EDGE */:
         return "clamp-to-edge";
-      case import_constants.GL.REPEAT:
+      case 10497 /* REPEAT */:
         return "repeat";
-      case import_constants.GL.MIRRORED_REPEAT:
+      case 33648 /* MIRRORED_REPEAT */:
         return "mirror-repeat";
       default:
         return void 0;
@@ -708,9 +712,9 @@ var __exports__ = (() => {
   }
   function convertSamplerMagFilter(mode) {
     switch (mode) {
-      case import_constants.GL.NEAREST:
+      case 9728 /* NEAREST */:
         return "nearest";
-      case import_constants.GL.LINEAR:
+      case 9729 /* LINEAR */:
         return "linear";
       default:
         return void 0;
@@ -718,17 +722,17 @@ var __exports__ = (() => {
   }
   function convertSamplerMinFilter(mode) {
     switch (mode) {
-      case import_constants.GL.NEAREST:
+      case 9728 /* NEAREST */:
         return { minFilter: "nearest" };
-      case import_constants.GL.LINEAR:
+      case 9729 /* LINEAR */:
         return { minFilter: "linear" };
-      case import_constants.GL.NEAREST_MIPMAP_NEAREST:
+      case 9984 /* NEAREST_MIPMAP_NEAREST */:
         return { minFilter: "nearest", mipmapFilter: "nearest" };
-      case import_constants.GL.LINEAR_MIPMAP_NEAREST:
+      case 9985 /* LINEAR_MIPMAP_NEAREST */:
         return { minFilter: "linear", mipmapFilter: "nearest" };
-      case import_constants.GL.NEAREST_MIPMAP_LINEAR:
+      case 9986 /* NEAREST_MIPMAP_LINEAR */:
         return { minFilter: "nearest", mipmapFilter: "linear" };
-      case import_constants.GL.LINEAR_MIPMAP_LINEAR:
+      case 9987 /* LINEAR_MIPMAP_LINEAR */:
         return { minFilter: "linear", mipmapFilter: "linear" };
       default:
         return {};
@@ -760,7 +764,8 @@ var __exports__ = (() => {
     if (imageBasedLightingEnvironment) {
       parsedMaterial.bindings.pbr_diffuseEnvSampler = imageBasedLightingEnvironment.diffuseEnvSampler.texture;
       parsedMaterial.bindings.pbr_specularEnvSampler = imageBasedLightingEnvironment.specularEnvSampler.texture;
-      parsedMaterial.bindings.pbr_BrdfLUT = imageBasedLightingEnvironment.brdfLutTexture.texture;
+      parsedMaterial.bindings.pbr_brdfLUT = imageBasedLightingEnvironment.brdfLutTexture.texture;
+      parsedMaterial.uniforms.IBLenabled = true;
       parsedMaterial.uniforms.scaleIBLAmbient = [1, 1];
     }
     if (options?.pbrDebug) {
@@ -774,6 +779,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)
@@ -781,81 +788,181 @@ var __exports__ = (() => {
     if (options?.lights)
       parsedMaterial.defines["USE_LIGHTS"] = true;
     if (material) {
-      parseMaterial(device, material, parsedMaterial);
+      if (options.validateAttributes !== false) {
+        warnOnMissingExpectedAttributes(material, attributes);
+      }
+      parseMaterial(device, material, parsedMaterial, options.gltf);
     }
     return parsedMaterial;
   }
-  function parseMaterial(device, material, parsedMaterial) {
-    parsedMaterial.uniforms.unlit = Boolean(material.unlit);
+  function warnOnMissingExpectedAttributes(material, attributes) {
+    const uvDependentTextureSlots = getUvDependentTextureSlots(material);
+    if (uvDependentTextureSlots.length > 0 && !attributes["TEXCOORD_0"]) {
+      import_core.log.warn(
+        `glTF material uses ${uvDependentTextureSlots.join(", ")} but primitive is missing TEXCOORD_0; textured shading will sample the default UV coordinates`
+      )();
+    }
+    const isUnlitMaterial = Boolean(material.unlit || material.extensions?.KHR_materials_unlit);
+    if (isUnlitMaterial || attributes["NORMAL"]) {
+      return;
+    }
+    const missingNormalReason = material.normalTexture ? "lit PBR shading with normalTexture" : "lit PBR shading";
+    import_core.log.warn(
+      `glTF primitive is missing NORMAL while using ${missingNormalReason}; shading will fall back to geometric normals`
+    )();
+  }
+  function getUvDependentTextureSlots(material) {
+    const uvDependentTextureSlots = [];
+    if (material.pbrMetallicRoughness?.baseColorTexture) {
+      uvDependentTextureSlots.push("baseColorTexture");
+    }
+    if (material.pbrMetallicRoughness?.metallicRoughnessTexture) {
+      uvDependentTextureSlots.push("metallicRoughnessTexture");
+    }
+    if (material.normalTexture) {
+      uvDependentTextureSlots.push("normalTexture");
+    }
+    if (material.occlusionTexture) {
+      uvDependentTextureSlots.push("occlusionTexture");
+    }
+    if (material.emissiveTexture) {
+      uvDependentTextureSlots.push("emissiveTexture");
+    }
+    if (material.extensions?.KHR_materials_specular?.specularTexture) {
+      uvDependentTextureSlots.push("KHR_materials_specular.specularTexture");
+    }
+    if (material.extensions?.KHR_materials_specular?.specularColorTexture) {
+      uvDependentTextureSlots.push("KHR_materials_specular.specularColorTexture");
+    }
+    if (material.extensions?.KHR_materials_transmission?.transmissionTexture) {
+      uvDependentTextureSlots.push("KHR_materials_transmission.transmissionTexture");
+    }
+    if (material.extensions?.KHR_materials_clearcoat?.clearcoatTexture) {
+      uvDependentTextureSlots.push("KHR_materials_clearcoat.clearcoatTexture");
+    }
+    if (material.extensions?.KHR_materials_clearcoat?.clearcoatRoughnessTexture) {
+      uvDependentTextureSlots.push("KHR_materials_clearcoat.clearcoatRoughnessTexture");
+    }
+    if (material.extensions?.KHR_materials_sheen?.sheenColorTexture) {
+      uvDependentTextureSlots.push("KHR_materials_sheen.sheenColorTexture");
+    }
+    if (material.extensions?.KHR_materials_sheen?.sheenRoughnessTexture) {
+      uvDependentTextureSlots.push("KHR_materials_sheen.sheenRoughnessTexture");
+    }
+    if (material.extensions?.KHR_materials_iridescence?.iridescenceTexture) {
+      uvDependentTextureSlots.push("KHR_materials_iridescence.iridescenceTexture");
+    }
+    if (material.extensions?.KHR_materials_anisotropy?.anisotropyTexture) {
+      uvDependentTextureSlots.push("KHR_materials_anisotropy.anisotropyTexture");
+    }
+    return uvDependentTextureSlots;
+  }
+  function parseMaterial(device, material, parsedMaterial, gltf) {
+    parsedMaterial.uniforms.unlit = Boolean(
+      material.unlit || material.extensions?.KHR_materials_unlit
+    );
     if (material.pbrMetallicRoughness) {
-      parsePbrMetallicRoughness(device, material.pbrMetallicRoughness, parsedMaterial);
+      parsePbrMetallicRoughness(device, material.pbrMetallicRoughness, parsedMaterial, gltf);
     }
     if (material.normalTexture) {
-      addTexture(
-        device,
-        material.normalTexture,
-        "pbr_normalSampler",
-        "HAS_NORMALMAP",
-        parsedMaterial
-      );
+      addTexture(device, material.normalTexture, "pbr_normalSampler", parsedMaterial, {
+        featureOptions: {
+          define: "HAS_NORMALMAP",
+          enabledUniformName: "normalMapEnabled"
+        },
+        gltf
+      });
       const { scale: scale4 = 1 } = material.normalTexture;
       parsedMaterial.uniforms.normalScale = scale4;
     }
     if (material.occlusionTexture) {
-      addTexture(
-        device,
-        material.occlusionTexture,
-        "pbr_occlusionSampler",
-        "HAS_OCCLUSIONMAP",
-        parsedMaterial
-      );
+      addTexture(device, material.occlusionTexture, "pbr_occlusionSampler", parsedMaterial, {
+        featureOptions: {
+          define: "HAS_OCCLUSIONMAP",
+          enabledUniformName: "occlusionMapEnabled"
+        },
+        gltf
+      });
       const { strength = 1 } = material.occlusionTexture;
       parsedMaterial.uniforms.occlusionStrength = strength;
     }
+    parsedMaterial.uniforms.emissiveFactor = material.emissiveFactor || [0, 0, 0];
     if (material.emissiveTexture) {
-      addTexture(
-        device,
-        material.emissiveTexture,
-        "pbr_emissiveSampler",
-        "HAS_EMISSIVEMAP",
-        parsedMaterial
-      );
-      parsedMaterial.uniforms.emissiveFactor = material.emissiveFactor || [0, 0, 0];
+      addTexture(device, material.emissiveTexture, "pbr_emissiveSampler", parsedMaterial, {
+        featureOptions: {
+          define: "HAS_EMISSIVEMAP",
+          enabledUniformName: "emissiveMapEnabled"
+        },
+        gltf
+      });
     }
-    switch (material.alphaMode || "MASK") {
-      case "MASK":
+    parseMaterialExtensions(device, material.extensions, parsedMaterial, gltf);
+    switch (material.alphaMode || "OPAQUE") {
+      case "OPAQUE":
+        break;
+      case "MASK": {
         const { alphaCutoff = 0.5 } = material;
         parsedMaterial.defines["ALPHA_CUTOFF"] = true;
+        parsedMaterial.uniforms.alphaCutoffEnabled = true;
         parsedMaterial.uniforms.alphaCutoff = alphaCutoff;
         break;
+      }
       case "BLEND":
         import_core.log.warn("glTF BLEND alphaMode might not work well because it requires mesh sorting")();
-        parsedMaterial.parameters.blend = true;
-        parsedMaterial.parameters.blendColorOperation = "add";
-        parsedMaterial.parameters.blendColorSrcFactor = "src-alpha";
-        parsedMaterial.parameters.blendColorDstFactor = "one-minus-src-alpha";
-        parsedMaterial.parameters.blendAlphaOperation = "add";
-        parsedMaterial.parameters.blendAlphaSrcFactor = "one";
-        parsedMaterial.parameters.blendAlphaDstFactor = "one-minus-src-alpha";
-        parsedMaterial.glParameters["blend"] = true;
-        parsedMaterial.glParameters["blendEquation"] = import_constants2.GL.FUNC_ADD;
-        parsedMaterial.glParameters["blendFunc"] = [
-          import_constants2.GL.SRC_ALPHA,
-          import_constants2.GL.ONE_MINUS_SRC_ALPHA,
-          import_constants2.GL.ONE,
-          import_constants2.GL.ONE_MINUS_SRC_ALPHA
-        ];
+        applyAlphaBlendParameters(parsedMaterial);
         break;
     }
   }
-  function parsePbrMetallicRoughness(device, pbrMetallicRoughness, parsedMaterial) {
+  function applyAlphaBlendParameters(parsedMaterial) {
+    parsedMaterial.parameters.blend = true;
+    parsedMaterial.parameters.blendColorOperation = "add";
+    parsedMaterial.parameters.blendColorSrcFactor = "src-alpha";
+    parsedMaterial.parameters.blendColorDstFactor = "one-minus-src-alpha";
+    parsedMaterial.parameters.blendAlphaOperation = "add";
+    parsedMaterial.parameters.blendAlphaSrcFactor = "one";
+    parsedMaterial.parameters.blendAlphaDstFactor = "one-minus-src-alpha";
+    parsedMaterial.glParameters["blend"] = true;
+    parsedMaterial.glParameters["blendEquation"] = 32774 /* FUNC_ADD */;
+    parsedMaterial.glParameters["blendFunc"] = [
+      770 /* SRC_ALPHA */,
+      771 /* ONE_MINUS_SRC_ALPHA */,
+      1 /* ONE */,
+      771 /* ONE_MINUS_SRC_ALPHA */
+    ];
+  }
+  function applyTransmissionBlendApproximation(parsedMaterial) {
+    parsedMaterial.parameters.blend = true;
+    parsedMaterial.parameters.depthWriteEnabled = false;
+    parsedMaterial.parameters.blendColorOperation = "add";
+    parsedMaterial.parameters.blendColorSrcFactor = "one";
+    parsedMaterial.parameters.blendColorDstFactor = "one-minus-src-alpha";
+    parsedMaterial.parameters.blendAlphaOperation = "add";
+    parsedMaterial.parameters.blendAlphaSrcFactor = "one";
+    parsedMaterial.parameters.blendAlphaDstFactor = "one-minus-src-alpha";
+    parsedMaterial.glParameters["blend"] = true;
+    parsedMaterial.glParameters["depthMask"] = false;
+    parsedMaterial.glParameters["blendEquation"] = 32774 /* FUNC_ADD */;
+    parsedMaterial.glParameters["blendFunc"] = [
+      1 /* ONE */,
+      771 /* ONE_MINUS_SRC_ALPHA */,
+      1 /* ONE */,
+      771 /* ONE_MINUS_SRC_ALPHA */
+    ];
+  }
+  function parsePbrMetallicRoughness(device, pbrMetallicRoughness, parsedMaterial, gltf) {
     if (pbrMetallicRoughness.baseColorTexture) {
       addTexture(
         device,
         pbrMetallicRoughness.baseColorTexture,
         "pbr_baseColorSampler",
-        "HAS_BASECOLORMAP",
-        parsedMaterial
+        parsedMaterial,
+        {
+          featureOptions: {
+            define: "HAS_BASECOLORMAP",
+            enabledUniformName: "baseColorMapEnabled"
+          },
+          gltf
+        }
       );
     }
     parsedMaterial.uniforms.baseColorFactor = pbrMetallicRoughness.baseColorFactor || [1, 1, 1, 1];
@@ -864,20 +971,277 @@ var __exports__ = (() => {
         device,
         pbrMetallicRoughness.metallicRoughnessTexture,
         "pbr_metallicRoughnessSampler",
-        "HAS_METALROUGHNESSMAP",
-        parsedMaterial
+        parsedMaterial,
+        {
+          featureOptions: {
+            define: "HAS_METALROUGHNESSMAP",
+            enabledUniformName: "metallicRoughnessMapEnabled"
+          },
+          gltf
+        }
       );
     }
     const { metallicFactor = 1, roughnessFactor = 1 } = pbrMetallicRoughness;
     parsedMaterial.uniforms.metallicRoughnessValues = [metallicFactor, roughnessFactor];
   }
-  function addTexture(device, gltfTexture, uniformName, define, parsedMaterial) {
-    const image = gltfTexture.texture.source.image;
-    let textureOptions;
-    if (image.compressed) {
-      textureOptions = image;
-    } else {
-      textureOptions = { data: image };
+  function parseMaterialExtensions(device, extensions, parsedMaterial, gltf) {
+    if (!extensions) {
+      return;
+    }
+    if (hasMaterialExtensionShading(extensions)) {
+      parsedMaterial.defines["USE_MATERIAL_EXTENSIONS"] = true;
+    }
+    parseSpecularExtension(device, extensions.KHR_materials_specular, parsedMaterial, gltf);
+    parseIorExtension(extensions.KHR_materials_ior, parsedMaterial);
+    parseTransmissionExtension(device, extensions.KHR_materials_transmission, parsedMaterial, gltf);
+    parseVolumeExtension(device, extensions.KHR_materials_volume, parsedMaterial, gltf);
+    parseClearcoatExtension(device, extensions.KHR_materials_clearcoat, parsedMaterial, gltf);
+    parseSheenExtension(device, extensions.KHR_materials_sheen, parsedMaterial, gltf);
+    parseIridescenceExtension(device, extensions.KHR_materials_iridescence, parsedMaterial, gltf);
+    parseAnisotropyExtension(device, extensions.KHR_materials_anisotropy, parsedMaterial, gltf);
+    parseEmissiveStrengthExtension(extensions.KHR_materials_emissive_strength, parsedMaterial);
+  }
+  function hasMaterialExtensionShading(extensions) {
+    return Boolean(
+      extensions.KHR_materials_specular || extensions.KHR_materials_ior || extensions.KHR_materials_transmission || extensions.KHR_materials_volume || extensions.KHR_materials_clearcoat || extensions.KHR_materials_sheen || extensions.KHR_materials_iridescence || extensions.KHR_materials_anisotropy
+    );
+  }
+  function parseSpecularExtension(device, extension, parsedMaterial, gltf) {
+    if (!extension) {
+      return;
+    }
+    if (extension.specularColorFactor) {
+      parsedMaterial.uniforms.specularColorFactor = extension.specularColorFactor;
+    }
+    if (extension.specularFactor !== void 0) {
+      parsedMaterial.uniforms.specularIntensityFactor = extension.specularFactor;
+    }
+    if (extension.specularColorTexture) {
+      addTexture(device, extension.specularColorTexture, "pbr_specularColorSampler", parsedMaterial, {
+        featureOptions: {
+          define: "HAS_SPECULARCOLORMAP",
+          enabledUniformName: "specularColorMapEnabled"
+        },
+        gltf
+      });
+    }
+    if (extension.specularTexture) {
+      addTexture(device, extension.specularTexture, "pbr_specularIntensitySampler", parsedMaterial, {
+        featureOptions: {
+          define: "HAS_SPECULARINTENSITYMAP",
+          enabledUniformName: "specularIntensityMapEnabled"
+        },
+        gltf
+      });
+    }
+  }
+  function parseIorExtension(extension, parsedMaterial) {
+    if (extension?.ior !== void 0) {
+      parsedMaterial.uniforms.ior = extension.ior;
+    }
+  }
+  function parseTransmissionExtension(device, extension, parsedMaterial, gltf) {
+    if (!extension) {
+      return;
+    }
+    if (extension.transmissionFactor !== void 0) {
+      parsedMaterial.uniforms.transmissionFactor = extension.transmissionFactor;
+    }
+    if (extension.transmissionTexture) {
+      addTexture(device, extension.transmissionTexture, "pbr_transmissionSampler", parsedMaterial, {
+        featureOptions: {
+          define: "HAS_TRANSMISSIONMAP",
+          enabledUniformName: "transmissionMapEnabled"
+        },
+        gltf
+      });
+    }
+    if ((extension.transmissionFactor ?? 0) > 0 || extension.transmissionTexture) {
+      import_core.log.warn(
+        "KHR_materials_transmission uses a premultiplied-alpha blending approximation and may require mesh sorting"
+      )();
+      applyTransmissionBlendApproximation(parsedMaterial);
+    }
+  }
+  function parseVolumeExtension(device, extension, parsedMaterial, gltf) {
+    if (!extension) {
+      return;
+    }
+    if (extension.thicknessFactor !== void 0) {
+      parsedMaterial.uniforms.thicknessFactor = extension.thicknessFactor;
+    }
+    if (extension.thicknessTexture) {
+      addTexture(device, extension.thicknessTexture, "pbr_thicknessSampler", parsedMaterial, {
+        featureOptions: {
+          define: "HAS_THICKNESSMAP"
+        },
+        gltf
+      });
+    }
+    if (extension.attenuationDistance !== void 0) {
+      parsedMaterial.uniforms.attenuationDistance = extension.attenuationDistance;
+    }
+    if (extension.attenuationColor) {
+      parsedMaterial.uniforms.attenuationColor = extension.attenuationColor;
+    }
+  }
+  function parseClearcoatExtension(device, extension, parsedMaterial, gltf) {
+    if (!extension) {
+      return;
+    }
+    if (extension.clearcoatFactor !== void 0) {
+      parsedMaterial.uniforms.clearcoatFactor = extension.clearcoatFactor;
+    }
+    if (extension.clearcoatRoughnessFactor !== void 0) {
+      parsedMaterial.uniforms.clearcoatRoughnessFactor = extension.clearcoatRoughnessFactor;
+    }
+    if (extension.clearcoatTexture) {
+      addTexture(device, extension.clearcoatTexture, "pbr_clearcoatSampler", parsedMaterial, {
+        featureOptions: {
+          define: "HAS_CLEARCOATMAP",
+          enabledUniformName: "clearcoatMapEnabled"
+        },
+        gltf
+      });
+    }
+    if (extension.clearcoatRoughnessTexture) {
+      addTexture(
+        device,
+        extension.clearcoatRoughnessTexture,
+        "pbr_clearcoatRoughnessSampler",
+        parsedMaterial,
+        {
+          featureOptions: {
+            define: "HAS_CLEARCOATROUGHNESSMAP",
+            enabledUniformName: "clearcoatRoughnessMapEnabled"
+          },
+          gltf
+        }
+      );
+    }
+    if (extension.clearcoatNormalTexture) {
+      addTexture(
+        device,
+        extension.clearcoatNormalTexture,
+        "pbr_clearcoatNormalSampler",
+        parsedMaterial,
+        {
+          featureOptions: {
+            define: "HAS_CLEARCOATNORMALMAP"
+          },
+          gltf
+        }
+      );
+    }
+  }
+  function parseSheenExtension(device, extension, parsedMaterial, gltf) {
+    if (!extension) {
+      return;
+    }
+    if (extension.sheenColorFactor) {
+      parsedMaterial.uniforms.sheenColorFactor = extension.sheenColorFactor;
+    }
+    if (extension.sheenRoughnessFactor !== void 0) {
+      parsedMaterial.uniforms.sheenRoughnessFactor = extension.sheenRoughnessFactor;
+    }
+    if (extension.sheenColorTexture) {
+      addTexture(device, extension.sheenColorTexture, "pbr_sheenColorSampler", parsedMaterial, {
+        featureOptions: {
+          define: "HAS_SHEENCOLORMAP",
+          enabledUniformName: "sheenColorMapEnabled"
+        },
+        gltf
+      });
+    }
+    if (extension.sheenRoughnessTexture) {
+      addTexture(
+        device,
+        extension.sheenRoughnessTexture,
+        "pbr_sheenRoughnessSampler",
+        parsedMaterial,
+        {
+          featureOptions: {
+            define: "HAS_SHEENROUGHNESSMAP",
+            enabledUniformName: "sheenRoughnessMapEnabled"
+          },
+          gltf
+        }
+      );
+    }
+  }
+  function parseIridescenceExtension(device, extension, parsedMaterial, gltf) {
+    if (!extension) {
+      return;
+    }
+    if (extension.iridescenceFactor !== void 0) {
+      parsedMaterial.uniforms.iridescenceFactor = extension.iridescenceFactor;
+    }
+    if (extension.iridescenceIor !== void 0) {
+      parsedMaterial.uniforms.iridescenceIor = extension.iridescenceIor;
+    }
+    if (extension.iridescenceThicknessMinimum !== void 0 || extension.iridescenceThicknessMaximum !== void 0) {
+      parsedMaterial.uniforms.iridescenceThicknessRange = [
+        extension.iridescenceThicknessMinimum ?? 100,
+        extension.iridescenceThicknessMaximum ?? 400
+      ];
+    }
+    if (extension.iridescenceTexture) {
+      addTexture(device, extension.iridescenceTexture, "pbr_iridescenceSampler", parsedMaterial, {
+        featureOptions: {
+          define: "HAS_IRIDESCENCEMAP",
+          enabledUniformName: "iridescenceMapEnabled"
+        },
+        gltf
+      });
+    }
+    if (extension.iridescenceThicknessTexture) {
+      addTexture(
+        device,
+        extension.iridescenceThicknessTexture,
+        "pbr_iridescenceThicknessSampler",
+        parsedMaterial,
+        {
+          featureOptions: {
+            define: "HAS_IRIDESCENCETHICKNESSMAP"
+          },
+          gltf
+        }
+      );
+    }
+  }
+  function parseAnisotropyExtension(device, extension, parsedMaterial, gltf) {
+    if (!extension) {
+      return;
+    }
+    if (extension.anisotropyStrength !== void 0) {
+      parsedMaterial.uniforms.anisotropyStrength = extension.anisotropyStrength;
+    }
+    if (extension.anisotropyRotation !== void 0) {
+      parsedMaterial.uniforms.anisotropyRotation = extension.anisotropyRotation;
+    }
+    if (extension.anisotropyTexture) {
+      addTexture(device, extension.anisotropyTexture, "pbr_anisotropySampler", parsedMaterial, {
+        featureOptions: {
+          define: "HAS_ANISOTROPYMAP",
+          enabledUniformName: "anisotropyMapEnabled"
+        },
+        gltf
+      });
+    }
+  }
+  function parseEmissiveStrengthExtension(extension, parsedMaterial) {
+    if (extension?.emissiveStrength !== void 0) {
+      parsedMaterial.uniforms.emissiveStrength = extension.emissiveStrength;
+    }
+  }
+  function addTexture(device, gltfTexture, uniformName, parsedMaterial, textureParseOptions = {}) {
+    const { featureOptions = {}, gltf } = textureParseOptions;
+    const { define, enabledUniformName } = featureOptions;
+    const resolvedTextureInfo = resolveTextureInfo(gltfTexture, gltf);
+    const image = resolvedTextureInfo.texture?.source?.image;
+    if (!image) {
+      import_core.log.warn(`Skipping unresolved glTF texture for ${String(uniformName)}`)();
+      return;
     }
     const gltfSampler = {
       wrapS: 10497,
@@ -888,18 +1252,150 @@ var __exports__ = (() => {
       // default LINEAR filtering
       magFilter: 9729,
       // default LINEAR filtering
-      ...gltfTexture?.texture?.sampler
+      ...resolvedTextureInfo?.texture?.sampler
     };
-    const texture = device.createTexture({
-      id: gltfTexture.uniformName || gltfTexture.id,
-      sampler: convertSampler(gltfSampler),
-      ...textureOptions
-    });
+    const baseOptions = {
+      id: resolvedTextureInfo.uniformName || resolvedTextureInfo.id,
+      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;
+    if (enabledUniformName) {
+      parsedMaterial.uniforms[enabledUniformName] = true;
+    }
     parsedMaterial.generatedTextures.push(texture);
   }
+  function resolveTextureInfo(gltfTexture, gltf) {
+    if (gltfTexture.texture || gltfTexture.index === void 0 || !gltf?.textures) {
+      return gltfTexture;
+    }
+    const resolvedTextureEntry = gltf.textures[gltfTexture.index];
+    if (!resolvedTextureEntry) {
+      return gltfTexture;
+    }
+    if ("texture" in resolvedTextureEntry && resolvedTextureEntry.texture) {
+      return {
+        ...resolvedTextureEntry,
+        ...gltfTexture,
+        texture: resolvedTextureEntry.texture
+      };
+    }
+    if (!("source" in resolvedTextureEntry)) {
+      return gltfTexture;
+    }
+    return {
+      ...gltfTexture,
+      texture: resolvedTextureEntry
+    };
+  }
+  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;
@@ -3473,33 +3969,42 @@ var __exports__ = (() => {
   };
 
   // src/parsers/parse-gltf-lights.ts
+  var GLTF_COLOR_FACTOR = 255;
   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 = [];
+    const parentNodeById = createParentNodeMap(gltf.nodes || []);
+    const worldMatrixByNodeId = /* @__PURE__ */ new Map();
     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;
       }
-      const color = gltfLight.color || [1, 1, 1];
+      const color = normalizeGLTFLightColor(
+        gltfLight.color || [1, 1, 1]
+      );
       const intensity = gltfLight.intensity ?? 1;
       const range = gltfLight.range;
+      const worldMatrix = getNodeWorldMatrix(node, parentNodeById, worldMatrixByNodeId);
       switch (gltfLight.type) {
         case "directional":
-          lights.push(parseDirectionalLight(node, color, intensity));
+          lights.push(parseDirectionalLight(worldMatrix, color, intensity));
           break;
         case "point":
-          lights.push(parsePointLight(node, color, intensity, range));
+          lights.push(parsePointLight(worldMatrix, color, intensity, range));
           break;
         case "spot":
-          lights.push(parsePointLight(node, color, intensity, range));
+          lights.push(parseSpotLight(worldMatrix, color, intensity, range, gltfLight.spot));
           break;
         default:
           break;
@@ -3507,8 +4012,11 @@ var __exports__ = (() => {
     }
     return lights;
   }
-  function parsePointLight(node, color, intensity, range) {
-    const position = node.translation ? [...node.translation] : [0, 0, 0];
+  function normalizeGLTFLightColor(color) {
+    return color.map((component) => component * GLTF_COLOR_FACTOR);
+  }
+  function parsePointLight(worldMatrix, color, intensity, range) {
+    const position = getLightPosition(worldMatrix);
     let attenuation = [1, 0, 0];
     if (range !== void 0 && range > 0) {
       attenuation = [1, 0, 1 / (range * range)];
@@ -3521,12 +4029,8 @@ var __exports__ = (() => {
       attenuation
     };
   }
-  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]);
-    }
+  function parseDirectionalLight(worldMatrix, color, intensity) {
+    const direction = getLightDirection(worldMatrix);
     return {
       type: "directional",
       direction,
@@ -3534,9 +4038,72 @@ var __exports__ = (() => {
       intensity
     };
   }
+  function parseSpotLight(worldMatrix, color, intensity, range, spot = {}) {
+    const position = getLightPosition(worldMatrix);
+    const direction = getLightDirection(worldMatrix);
+    let attenuation = [1, 0, 0];
+    if (range !== void 0 && range > 0) {
+      attenuation = [1, 0, 1 / (range * range)];
+    }
+    return {
+      type: "spot",
+      position,
+      direction,
+      color,
+      intensity,
+      attenuation,
+      innerConeAngle: spot.innerConeAngle ?? 0,
+      outerConeAngle: spot.outerConeAngle ?? Math.PI / 4
+    };
+  }
+  function createParentNodeMap(nodes) {
+    const parentNodeById = /* @__PURE__ */ new Map();
+    for (const node of nodes) {
+      for (const childNode of node.children || []) {
+        parentNodeById.set(childNode.id, node);
+      }
+    }
+    return parentNodeById;
+  }
+  function getNodeWorldMatrix(node, parentNodeById, worldMatrixByNodeId) {
+    const cachedWorldMatrix = worldMatrixByNodeId.get(node.id);
+    if (cachedWorldMatrix) {
+      return cachedWorldMatrix;
+    }
+    const localMatrix = getNodeLocalMatrix(node);
+    const parentNode = parentNodeById.get(node.id);
+    const worldMatrix = parentNode ? new Matrix4(
+      getNodeWorldMatrix(parentNode, parentNodeById, worldMatrixByNodeId)
+    ).multiplyRight(localMatrix) : localMatrix;
+    worldMatrixByNodeId.set(node.id, worldMatrix);
+    return worldMatrix;
+  }
+  function getNodeLocalMatrix(node) {
+    if (node.matrix) {
+      return new Matrix4(node.matrix);
+    }
+    const matrix = new Matrix4();
+    if (node.translation) {
+      matrix.translate(node.translation);
+    }
+    if (node.rotation) {
+      matrix.multiplyRight(new Matrix4().fromQuaternion(node.rotation));
+    }
+    if (node.scale) {
+      matrix.scale(node.scale);
+    }
+    return matrix;
+  }
+  function getLightPosition(worldMatrix) {
+    return worldMatrix.transformAsPoint([0, 0, 0]);
+  }
+  function getLightDirection(worldMatrix) {
+    return worldMatrix.transformDirection([0, 0, -1]);
+  }
 
   // src/parsers/parse-gltf.ts
-  var import_engine3 = __toESM(require_engine(), 1);
+  var import_engine4 = __toESM(require_engine(), 1);
+  var import_shadertools2 = __toESM(require_shadertools(), 1);
 
   // src/webgl-to-webgpu/convert-webgl-topology.ts
   function convertGLDrawModeToTopology(drawMode) {
@@ -3558,55 +4125,94 @@ var __exports__ = (() => {
 
   // src/gltf/create-gltf-model.ts
   var import_core3 = __toESM(require_core(), 1);
-  var import_shadertools = __toESM(require_shadertools(), 1);
   var import_engine2 = __toESM(require_engine(), 1);
+  var import_shadertools = __toESM(require_shadertools(), 1);
+  var import_engine3 = __toESM(require_engine(), 1);
   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 = (
@@ -3630,6 +4236,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 +4258,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;
   }
 `
   );
@@ -3663,6 +4283,25 @@ layout(0) positions: vec4; // in vec4 POSITION;
   }
 `
   );
+  function createGLTFMaterial(device, options) {
+    const materialFactory = options.materialFactory || new import_engine3.MaterialFactory(device, { modules: [import_shadertools.pbrMaterial] });
+    const pbrMaterialProps = { ...options.parsedPPBRMaterial.uniforms };
+    delete pbrMaterialProps.camera;
+    const materialBindings = Object.fromEntries(
+      Object.entries({
+        ...pbrMaterialProps,
+        ...options.parsedPPBRMaterial.bindings
+      }).filter(
+        ([name, value]) => materialFactory.ownsBinding(name) && isMaterialBindingResource(value)
+      )
+    );
+    const material = materialFactory.createMaterial({
+      id: options.id,
+      bindings: materialBindings
+    });
+    material.setProps({ pbrMaterial: pbrMaterialProps });
+    return material;
+  }
   function createGLTFModel(device, options) {
     const { id, geometry, parsedPPBRMaterial, vertexCount, modelOptions = {} } = options;
     import_core3.log.info(4, "createGLTFModel defines: ", parsedPPBRMaterial.defines)();
@@ -3681,20 +4320,57 @@ 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 }
     };
-    const model = new import_engine2.Model(device, modelProps);
-    const { camera, ...pbrMaterialProps } = {
+    const material = options.material || createGLTFMaterial(device, {
+      id: id ? `${id}-material` : void 0,
+      parsedPPBRMaterial
+    });
+    modelProps.material = material;
+    const model = new import_engine3.Model(device, modelProps);
+    const sceneShaderInputValues = {
       ...parsedPPBRMaterial.uniforms,
       ...modelOptions.uniforms,
       ...parsedPPBRMaterial.bindings,
       ...modelOptions.bindings
     };
-    model.shaderInputs.setProps({ pbrMaterial: pbrMaterialProps, pbrProjection: { camera } });
-    return new import_engine2.ModelNode({ managedResources, model });
+    const sceneShaderInputProps = getSceneShaderInputProps(
+      model.shaderInputs.getModules(),
+      material,
+      sceneShaderInputValues
+    );
+    model.shaderInputs.setProps(sceneShaderInputProps);
+    return new import_engine3.ModelNode({ managedResources, model });
+  }
+  function isMaterialBindingResource(value) {
+    return value instanceof import_core3.Buffer || value instanceof import_engine2.DynamicTexture || value instanceof import_core3.Sampler || value instanceof import_core3.Texture || value instanceof import_core3.TextureView;
+  }
+  function getSceneShaderInputProps(modules, material, shaderInputValues) {
+    const propertyToModuleNameMap = /* @__PURE__ */ new Map();
+    for (const module of modules) {
+      for (const uniformName of Object.keys(module.uniformTypes || {})) {
+        propertyToModuleNameMap.set(uniformName, module.name);
+      }
+      for (const binding of module.bindingLayout || []) {
+        propertyToModuleNameMap.set(binding.name, module.name);
+      }
+    }
+    const sceneShaderInputProps = {};
+    for (const [propertyName, value] of Object.entries(shaderInputValues)) {
+      if (value === void 0) {
+        continue;
+      }
+      const moduleName = propertyToModuleNameMap.get(propertyName);
+      if (!moduleName || material.ownsModule(moduleName)) {
+        continue;
+      }
+      sceneShaderInputProps[moduleName] ||= {};
+      sceneShaderInputProps[moduleName][propertyName] = value;
+    }
+    return sceneShaderInputProps;
   }
 
   // src/parsers/parse-gltf.ts
@@ -3705,82 +4381,128 @@ 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)
+  function parseGLTF(device, gltf, options = {}) {
+    const combinedOptions = { ...defaultOptions, ...options };
+    const materialFactory = new import_engine4.MaterialFactory(device, { modules: [import_shadertools2.pbrMaterial] });
+    const materials = (gltf.materials || []).map(
+      (gltfMaterial, materialIndex) => createGLTFMaterial(device, {
+        id: getGLTFMaterialId(gltfMaterial, materialIndex),
+        parsedPPBRMaterial: parsePBRMaterial(
+          device,
+          gltfMaterial,
+          {},
+          {
+            ...combinedOptions,
+            gltf,
+            validateAttributes: false
+          }
+        ),
+        materialFactory
+      })
     );
-    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
+    const gltfMaterialIdToMaterialMap = /* @__PURE__ */ new Map();
+    (gltf.materials || []).forEach((gltfMaterial, materialIndex) => {
+      gltfMaterialIdToMaterialMap.set(gltfMaterial.id, materials[materialIndex]);
     });
-    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 gltfMeshIdToNodeMap = /* @__PURE__ */ new Map();
+    gltf.meshes.forEach((gltfMesh, idx) => {
+      const newMesh = createNodeForGLTFMesh(
+        device,
+        gltfMesh,
+        gltf,
+        gltfMaterialIdToMaterialMap,
+        combinedOptions
+      );
+      gltfMeshIdToNodeMap.set(gltfMesh.id, newMesh);
+    });
+    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 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_engine4.GroupNode({
+        id: gltfScene.name || gltfScene.id,
+        children
+      });
+    });
+    return { scenes, materials, gltfMeshIdToNodeMap, gltfNodeIdToNodeMap, gltfNodeIndexToNodeMap };
+  }
+  function createNodeForGLTFNode(device, gltfNode, options) {
+    return new import_engine4.GroupNode({
+      id: gltfNode.name || gltfNode.id,
+      children: [],
+      matrix: gltfNode.matrix,
+      position: gltfNode.translation,
+      rotation: gltfNode.rotation,
+      scale: gltfNode.scale
+    });
   }
-  function createPrimitive(device, gltfPrimitive, i, gltfMesh, options) {
-    const id = gltfPrimitive.name || `${gltfMesh.name || gltfMesh.id}-primitive-${i}`;
+  function createNodeForGLTFMesh(device, gltfMesh, gltf, gltfMaterialIdToMaterialMap, options) {
+    const gltfPrimitives = gltfMesh.primitives || [];
+    const primitives = gltfPrimitives.map(
+      (gltfPrimitive, i) => createNodeForGLTFPrimitive({
+        device,
+        gltfPrimitive,
+        primitiveIndex: i,
+        gltfMesh,
+        gltf,
+        gltfMaterialIdToMaterialMap,
+        options
+      })
+    );
+    const mesh = new import_engine4.GroupNode({
+      id: gltfMesh.name || gltfMesh.id,
+      children: primitives
+    });
+    return mesh;
+  }
+  function createNodeForGLTFPrimitive({
+    device,
+    gltfPrimitive,
+    primitiveIndex,
+    gltfMesh,
+    gltf,
+    gltfMaterialIdToMaterialMap,
+    options
+  }) {
+    const id = gltfPrimitive.name || `${gltfMesh.name || gltfMesh.id}-primitive-${primitiveIndex}`;
     const topology = convertGLDrawModeToTopology(gltfPrimitive.mode || 4);
     const vertexCount = gltfPrimitive.indices ? gltfPrimitive.indices.count : getVertexCount(gltfPrimitive.attributes);
     const geometry = createGeometry(id, gltfPrimitive, topology);
-    const parsedPPBRMaterial = parsePBRMaterial(
-      device,
-      gltfPrimitive.material,
-      geometry.attributes,
-      options
-    );
+    const parsedPPBRMaterial = parsePBRMaterial(device, gltfPrimitive.material, geometry.attributes, {
+      ...options,
+      gltf
+    });
     const modelNode = createGLTFModel(device, {
       id,
       geometry: createGeometry(id, gltfPrimitive, topology),
+      material: gltfPrimitive.material ? gltfMaterialIdToMaterialMap.get(gltfPrimitive.material.id) || null : null,
       parsedPPBRMaterial,
       modelOptions: options.modelOptions,
       vertexCount
@@ -3797,40 +4519,40 @@ layout(0) positions: vec4; // in vec4 POSITION;
       const { components, size, value } = attribute;
       attributes[attributeName] = { size: size ?? components, value };
     }
-    return new import_engine3.Geometry({
+    return new import_engine4.Geometry({
       id,
       topology,
       indices: gltfPrimitive.indices.value,
       attributes
     });
   }
+  function getGLTFMaterialId(gltfMaterial, materialIndex) {
+    return gltfMaterial.name || gltfMaterial.id || `material-${materialIndex}`;
+  }
 
   // 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 +4562,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 +4577,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 +4600,83 @@ 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/parsers/parse-gltf-animations.ts
+  var import_core7 = __toESM(require_core(), 1);
 
   // src/webgl-to-webgpu/convert-webgl-attribute.ts
   var ATTRIBUTE_TYPE_TO_COMPONENTS = {
@@ -3996,65 +4708,331 @@ layout(0) positions: vec4; // in vec4 POSITION;
   // src/parsers/parse-gltf-animations.ts
   function parseGLTFAnimations(gltf) {
     const gltfAnimations = gltf.animations || [];
-    return gltfAnimations.map((animation, index) => {
+    const accessorCache1D = /* @__PURE__ */ new Map();
+    const accessorCache2D = /* @__PURE__ */ new Map();
+    return gltfAnimations.flatMap((animation, index) => {
       const name = animation.name || `Animation-${index}`;
-      const samplers = animation.samplers.map(
-        ({ input, interpolation = "LINEAR", output }) => ({
-          input: accessorToJsArray(gltf.accessors[input]),
-          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
-      }));
-      return { name, channels };
+      const samplerCache = /* @__PURE__ */ new Map();
+      const channels = animation.channels.flatMap(({ sampler, target }) => {
+        const path = getSupportedAnimationPath(target.path);
+        if (!path) {
+          return [];
+        }
+        const targetNode = gltf.nodes[target.node ?? 0];
+        if (!targetNode) {
+          throw new Error(`Cannot find animation target ${target.node}`);
+        }
+        let parsedSampler = samplerCache.get(sampler);
+        if (!parsedSampler) {
+          const gltfSampler = animation.samplers[sampler];
+          if (!gltfSampler) {
+            throw new Error(`Cannot find animation sampler ${sampler}`);
+          }
+          const { input, interpolation = "LINEAR", output } = gltfSampler;
+          parsedSampler = {
+            input: accessorToJsArray1D(gltf.accessors[input], accessorCache1D),
+            interpolation,
+            output: accessorToJsArray2D(gltf.accessors[output], accessorCache2D)
+          };
+          samplerCache.set(sampler, parsedSampler);
+        }
+        return {
+          sampler: parsedSampler,
+          targetNodeId: targetNode.id,
+          path
+        };
+      });
+      return channels.length ? [{ 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 getSupportedAnimationPath(path) {
+    if (path === "pointer") {
+      import_core7.log.warn("KHR_animation_pointer channels are not supported and will be skipped")();
+      return null;
     }
-    return accessor._animation;
+    return path;
   }
-
-  // src/utils/deep-copy.ts
-  function deepCopy(object) {
-    if (ArrayBuffer.isView(object) || object instanceof ArrayBuffer || object instanceof ImageBitmap) {
-      return object;
+  function accessorToJsArray1D(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, "accessorToJsArray1D must have exactly 1 component");
+    const result = Array.from(array);
+    accessorCache.set(accessor, result);
+    return result;
+  }
+  function accessorToJsArray2D(accessor, accessorCache) {
+    if (accessorCache.has(accessor)) {
+      return accessorCache.get(accessor);
+    }
+    const { typedArray: array, components } = accessorToTypedArray(accessor);
+    assert3(components >= 1, "accessorToJsArray2D must have at least 1 component");
+    const result = [];
+    for (let i = 0; i < array.length; i += components) {
+      result.push(Array.from(array.slice(i, i + components)));
+    }
+    accessorCache.set(accessor, result);
+    return result;
+  }
+  function assert3(condition, message) {
+    if (!condition) {
+      throw new Error(message);
     }
-    if (object && typeof object === "object") {
-      const result = {};
-      for (const key in object) {
-        result[key] = deepCopy(object[key]);
+  }
+
+  // src/gltf/gltf-extension-support.ts
+  var UNKNOWN_EXTENSION_SUPPORT = {
+    supportLevel: "none",
+    comment: "Not currently listed in the luma.gl glTF extension support registry."
+  };
+  var GLTF_EXTENSION_SUPPORT_REGISTRY = {
+    KHR_draco_mesh_compression: {
+      supportLevel: "built-in",
+      comment: "Decoded by loaders.gl before luma.gl builds the scenegraph."
+    },
+    EXT_meshopt_compression: {
+      supportLevel: "built-in",
+      comment: "Meshopt-compressed primitives are decoded during load."
+    },
+    KHR_mesh_quantization: {
+      supportLevel: "built-in",
+      comment: "Quantized accessors are unpacked before geometry creation."
+    },
+    KHR_lights_punctual: {
+      supportLevel: "built-in",
+      comment: "Parsed into luma.gl Light objects."
+    },
+    KHR_materials_unlit: {
+      supportLevel: "built-in",
+      comment: "Unlit materials bypass the default lighting path."
+    },
+    KHR_materials_emissive_strength: {
+      supportLevel: "built-in",
+      comment: "Applied by the stock PBR shader."
+    },
+    KHR_texture_basisu: {
+      supportLevel: "built-in",
+      comment: "BasisU / KTX2 textures pass through when the device supports them."
+    },
+    KHR_texture_transform: {
+      supportLevel: "built-in",
+      comment: "UV transforms are applied during load."
+    },
+    EXT_texture_webp: {
+      supportLevel: "loader-only",
+      comment: "Texture source is resolved during load; final support depends on browser and device decode support."
+    },
+    EXT_texture_avif: {
+      supportLevel: "loader-only",
+      comment: "Texture source is resolved during load; final support depends on browser and device decode support."
+    },
+    KHR_materials_specular: {
+      supportLevel: "built-in",
+      comment: "The stock shader now applies specular factors and textures to the dielectric F0 term."
+    },
+    KHR_materials_ior: {
+      supportLevel: "built-in",
+      comment: "The stock shader now drives dielectric reflectance from the glTF IOR value."
+    },
+    KHR_materials_transmission: {
+      supportLevel: "built-in",
+      comment: "The stock shader now applies transmission to the base layer and exposes transparency through alpha, without a scene-color refraction buffer."
+    },
+    KHR_materials_volume: {
+      supportLevel: "built-in",
+      comment: "Thickness and attenuation now tint transmitted light in the stock shader."
+    },
+    KHR_materials_clearcoat: {
+      supportLevel: "built-in",
+      comment: "The stock shader now adds a secondary clearcoat specular lobe."
+    },
+    KHR_materials_sheen: {
+      supportLevel: "built-in",
+      comment: "The stock shader now adds a sheen lobe for cloth-like materials."
+    },
+    KHR_materials_iridescence: {
+      supportLevel: "built-in",
+      comment: "The stock shader now tints specular response with a view-dependent thin-film iridescence approximation."
+    },
+    KHR_materials_anisotropy: {
+      supportLevel: "built-in",
+      comment: "The stock shader now shapes highlights and IBL response with an anisotropy-direction approximation."
+    },
+    KHR_materials_pbrSpecularGlossiness: {
+      supportLevel: "loader-only",
+      comment: "Extension data can be loaded, but it is not translated into the default metallic-roughness material path."
+    },
+    KHR_materials_variants: {
+      supportLevel: "loader-only",
+      comment: "Variant metadata can be loaded, but applications must choose and apply variants."
+    },
+    EXT_mesh_gpu_instancing: {
+      supportLevel: "none",
+      comment: "GPU instancing data is not yet converted into luma.gl instanced draw setup."
+    },
+    KHR_node_visibility: {
+      supportLevel: "none",
+      comment: "Node-visibility animations and toggles are not mapped onto runtime scenegraph state."
+    },
+    KHR_animation_pointer: {
+      supportLevel: "none",
+      comment: "Animation pointers are not mapped onto runtime scenegraph updates."
+    },
+    KHR_materials_diffuse_transmission: {
+      supportLevel: "none",
+      comment: "Diffuse-transmission shading is not implemented in the stock PBR shader."
+    },
+    KHR_materials_dispersion: {
+      supportLevel: "none",
+      comment: "Chromatic dispersion is not implemented in the stock PBR shader."
+    },
+    KHR_materials_volume_scatter: {
+      supportLevel: "none",
+      comment: "Volume scattering is not implemented in the stock PBR shader."
+    },
+    KHR_xmp: {
+      supportLevel: "none",
+      comment: "Metadata payloads remain in the loaded glTF, but luma.gl does not interpret them."
+    },
+    KHR_xmp_json_ld: {
+      supportLevel: "none",
+      comment: "Metadata is preserved in the glTF, but luma.gl does not interpret it."
+    },
+    EXT_lights_image_based: {
+      supportLevel: "none",
+      comment: "Use loadPBREnvironment() or custom environment setup instead."
+    },
+    EXT_texture_video: {
+      supportLevel: "none",
+      comment: "Video textures are not created automatically by the stock pipeline."
+    },
+    MSFT_lod: {
+      supportLevel: "none",
+      comment: "Level-of-detail switching is not implemented in the stock scenegraph loader."
+    }
+  };
+  function getGLTFExtensionSupport(gltf) {
+    const extensionNames = Array.from(collectGLTFExtensionNames(gltf)).sort();
+    const extensionSupportEntries = extensionNames.map(
+      (extensionName) => {
+        const extensionSupportDefinition = GLTF_EXTENSION_SUPPORT_REGISTRY[extensionName] || UNKNOWN_EXTENSION_SUPPORT;
+        return [
+          extensionName,
+          {
+            extensionName,
+            supported: extensionSupportDefinition.supportLevel === "built-in",
+            supportLevel: extensionSupportDefinition.supportLevel,
+            comment: extensionSupportDefinition.comment
+          }
+        ];
       }
-      return result;
+    );
+    return new Map(extensionSupportEntries);
+  }
+  function collectGLTFExtensionNames(gltf) {
+    const gltfWithRemovedExtensions = gltf;
+    const extensionNames = /* @__PURE__ */ new Set();
+    addExtensionNames(extensionNames, gltf.extensionsUsed);
+    addExtensionNames(extensionNames, gltf.extensionsRequired);
+    addExtensionNames(extensionNames, gltfWithRemovedExtensions.extensionsRemoved);
+    addExtensionNames(extensionNames, Object.keys(gltf.extensions || {}));
+    if (gltfWithRemovedExtensions.lights?.length || gltf.nodes.some((node) => "light" in node)) {
+      extensionNames.add("KHR_lights_punctual");
+    }
+    if (gltf.materials.some((material) => {
+      const gltfMaterial = material;
+      return gltfMaterial.unlit || gltfMaterial.extensions?.KHR_materials_unlit;
+    })) {
+      extensionNames.add("KHR_materials_unlit");
+    }
+    return extensionNames;
+  }
+  function addExtensionNames(extensionNames, newExtensionNames = []) {
+    for (const extensionName of newExtensionNames) {
+      extensionNames.add(extensionName);
     }
-    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, materials, 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 };
+    const extensionSupport = getGLTFExtensionSupport(gltf);
+    const sceneBounds = scenes.map((scene) => getScenegraphBounds(scene.getBounds()));
+    const modelBounds = getCombinedScenegraphBounds(sceneBounds);
+    return {
+      scenes,
+      materials,
+      animator,
+      lights,
+      extensionSupport,
+      sceneBounds,
+      modelBounds,
+      gltfMeshIdToNodeMap,
+      gltfNodeIdToNodeMap,
+      gltfNodeIndexToNodeMap,
+      gltf
+    };
+  }
+  function getScenegraphBounds(bounds) {
+    if (!bounds) {
+      return {
+        bounds: null,
+        center: [0, 0, 0],
+        size: [0, 0, 0],
+        radius: 0.5,
+        recommendedOrbitDistance: 1
+      };
+    }
+    const normalizedBounds = [
+      [bounds[0][0], bounds[0][1], bounds[0][2]],
+      [bounds[1][0], bounds[1][1], bounds[1][2]]
+    ];
+    const size = [
+      normalizedBounds[1][0] - normalizedBounds[0][0],
+      normalizedBounds[1][1] - normalizedBounds[0][1],
+      normalizedBounds[1][2] - normalizedBounds[0][2]
+    ];
+    const center = [
+      normalizedBounds[0][0] + size[0] * 0.5,
+      normalizedBounds[0][1] + size[1] * 0.5,
+      normalizedBounds[0][2] + size[2] * 0.5
+    ];
+    const maxHalfExtent = Math.max(size[0], size[1], size[2]) * 0.5;
+    const radius = Math.max(0.5 * Math.hypot(size[0], size[1], size[2]), 1e-3);
+    return {
+      bounds: normalizedBounds,
+      center,
+      size,
+      radius,
+      recommendedOrbitDistance: Math.max(
+        Math.max(maxHalfExtent, 1e-3) / Math.tan(Math.PI / 6) * 1.15,
+        radius * 1.1
+      )
+    };
+  }
+  function getCombinedScenegraphBounds(sceneBounds) {
+    let combinedBounds = null;
+    for (const sceneBoundInfo of sceneBounds) {
+      if (!sceneBoundInfo.bounds) {
+        continue;
+      }
+      if (!combinedBounds) {
+        combinedBounds = [
+          [...sceneBoundInfo.bounds[0]],
+          [...sceneBoundInfo.bounds[1]]
+        ];
+        continue;
+      }
+      for (let axis = 0; axis < 3; axis++) {
+        combinedBounds[0][axis] = Math.min(combinedBounds[0][axis], sceneBoundInfo.bounds[0][axis]);
+        combinedBounds[1][axis] = Math.max(combinedBounds[1][axis], sceneBoundInfo.bounds[1][axis]);
+      }
+    }
+    return getScenegraphBounds(combinedBounds);
   }
   return __toCommonJS(bundle_exports);
 })();