@luma.gl/gltf 9.2.6 → 9.3.0-alpha.10

package/dist/index.cjs

@@ -22,7 +22,9 @@ var dist_exports = {};
 __export(dist_exports, {
   GLTFAnimator: () => GLTFAnimator,
   createScenegraphsFromGLTF: () => createScenegraphsFromGLTF,
+  getGLTFExtensionSupport: () => getGLTFExtensionSupport,
   loadPBREnvironment: () => loadPBREnvironment,
+  parseGLTFLights: () => parseGLTFLights,
   parsePBRMaterial: () => parsePBRMaterial
 });
 module.exports = __toCommonJS(dist_exports);
@@ -31,7 +33,8 @@ module.exports = __toCommonJS(dist_exports);
 var import_engine = require("@luma.gl/engine");
 var import_textures = require("@loaders.gl/textures");
 function loadPBREnvironment(device, props) {
-  const brdfLutTexture = new import_engine.AsyncTexture(device, {
+  const specularMipLevels = props.specularMipLevels ?? 1;
+  const brdfLutTexture = new import_engine.DynamicTexture(device, {
     id: "brdfLUT",
     sampler: {
       addressModeU: "clamp-to-edge",
@@ -44,7 +47,7 @@ function loadPBREnvironment(device, props) {
   });
   const diffuseEnvSampler = makeCube(device, {
     id: "DiffuseEnvSampler",
-    getTextureForFace: (dir) => (0, import_textures.loadImageTexture)(props.getTexUrl("diffuse", dir, 0)),
+    getTextureForFace: (face) => (0, import_textures.loadImageTexture)(props.getTexUrl("diffuse", FACES.indexOf(face), 0)),
     sampler: {
       addressModeU: "clamp-to-edge",
       addressModeV: "clamp-to-edge",
@@ -54,12 +57,13 @@ function loadPBREnvironment(device, props) {
   });
   const specularEnvSampler = makeCube(device, {
     id: "SpecularEnvSampler",
-    getTextureForFace: (dir) => {
+    getTextureForFace: (face) => {
       const imageArray = [];
-      for (let lod = 0; lod <= props.specularMipLevels - 1; lod++) {
-        imageArray.push((0, import_textures.loadImageTexture)(props.getTexUrl("specular", dir, lod)));
+      const direction = FACES.indexOf(face);
+      for (let lod = 0; lod < specularMipLevels; lod++) {
+        imageArray.push((0, import_textures.loadImageTexture)(props.getTexUrl("specular", direction, lod)));
       }
-      return imageArray;
+      return Promise.all(imageArray);
     },
     sampler: {
       addressModeU: "clamp-to-edge",
@@ -75,28 +79,57 @@ function loadPBREnvironment(device, props) {
     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.AsyncTexture(device, {
+  return new import_engine.DynamicTexture(device, {
     id,
     dimension: "cube",
     mipmaps: false,
     sampler,
-    // @ts-expect-error
     data
   });
 }
 
 // dist/parsers/parse-pbr-material.js
-var import_constants2 = require("@luma.gl/constants");
 var import_core = require("@luma.gl/core");
 
+// dist/webgl-to-webgpu/gltf-webgl-constants.js
+var GLEnum;
+(function(GLEnum2) {
+  GLEnum2[GLEnum2["POINTS"] = 0] = "POINTS";
+  GLEnum2[GLEnum2["LINES"] = 1] = "LINES";
+  GLEnum2[GLEnum2["LINE_LOOP"] = 2] = "LINE_LOOP";
+  GLEnum2[GLEnum2["LINE_STRIP"] = 3] = "LINE_STRIP";
+  GLEnum2[GLEnum2["TRIANGLES"] = 4] = "TRIANGLES";
+  GLEnum2[GLEnum2["TRIANGLE_STRIP"] = 5] = "TRIANGLE_STRIP";
+  GLEnum2[GLEnum2["TRIANGLE_FAN"] = 6] = "TRIANGLE_FAN";
+  GLEnum2[GLEnum2["ONE"] = 1] = "ONE";
+  GLEnum2[GLEnum2["SRC_ALPHA"] = 770] = "SRC_ALPHA";
+  GLEnum2[GLEnum2["ONE_MINUS_SRC_ALPHA"] = 771] = "ONE_MINUS_SRC_ALPHA";
+  GLEnum2[GLEnum2["FUNC_ADD"] = 32774] = "FUNC_ADD";
+  GLEnum2[GLEnum2["LINEAR"] = 9729] = "LINEAR";
+  GLEnum2[GLEnum2["NEAREST"] = 9728] = "NEAREST";
+  GLEnum2[GLEnum2["NEAREST_MIPMAP_NEAREST"] = 9984] = "NEAREST_MIPMAP_NEAREST";
+  GLEnum2[GLEnum2["LINEAR_MIPMAP_NEAREST"] = 9985] = "LINEAR_MIPMAP_NEAREST";
+  GLEnum2[GLEnum2["NEAREST_MIPMAP_LINEAR"] = 9986] = "NEAREST_MIPMAP_LINEAR";
+  GLEnum2[GLEnum2["LINEAR_MIPMAP_LINEAR"] = 9987] = "LINEAR_MIPMAP_LINEAR";
+  GLEnum2[GLEnum2["TEXTURE_MIN_FILTER"] = 10241] = "TEXTURE_MIN_FILTER";
+  GLEnum2[GLEnum2["TEXTURE_WRAP_S"] = 10242] = "TEXTURE_WRAP_S";
+  GLEnum2[GLEnum2["TEXTURE_WRAP_T"] = 10243] = "TEXTURE_WRAP_T";
+  GLEnum2[GLEnum2["REPEAT"] = 10497] = "REPEAT";
+  GLEnum2[GLEnum2["CLAMP_TO_EDGE"] = 33071] = "CLAMP_TO_EDGE";
+  GLEnum2[GLEnum2["MIRRORED_REPEAT"] = 33648] = "MIRRORED_REPEAT";
+  GLEnum2[GLEnum2["UNPACK_FLIP_Y_WEBGL"] = 37440] = "UNPACK_FLIP_Y_WEBGL";
+})(GLEnum || (GLEnum = {}));
+
 // dist/webgl-to-webgpu/convert-webgl-sampler.js
-var import_constants = require("@luma.gl/constants");
 function convertSampler(gltfSampler) {
   return {
     addressModeU: convertSamplerWrapMode(gltfSampler.wrapS),
@@ -107,11 +140,11 @@ function convertSampler(gltfSampler) {
 }
 function convertSamplerWrapMode(mode) {
   switch (mode) {
-    case 33071:
+    case GLEnum.CLAMP_TO_EDGE:
       return "clamp-to-edge";
-    case 10497:
+    case GLEnum.REPEAT:
       return "repeat";
-    case 33648:
+    case GLEnum.MIRRORED_REPEAT:
       return "mirror-repeat";
     default:
       return void 0;
@@ -119,9 +152,9 @@ function convertSamplerWrapMode(mode) {
 }
 function convertSamplerMagFilter(mode) {
   switch (mode) {
-    case 9728:
+    case GLEnum.NEAREST:
       return "nearest";
-    case 9729:
+    case GLEnum.LINEAR:
       return "linear";
     default:
       return void 0;
@@ -129,17 +162,17 @@ function convertSamplerMagFilter(mode) {
 }
 function convertSamplerMinFilter(mode) {
   switch (mode) {
-    case 9728:
+    case GLEnum.NEAREST:
       return { minFilter: "nearest" };
-    case 9729:
+    case GLEnum.LINEAR:
       return { minFilter: "linear" };
-    case 9984:
+    case GLEnum.NEAREST_MIPMAP_NEAREST:
       return { minFilter: "nearest", mipmapFilter: "nearest" };
-    case 9985:
+    case GLEnum.LINEAR_MIPMAP_NEAREST:
       return { minFilter: "linear", mipmapFilter: "nearest" };
-    case 9986:
+    case GLEnum.NEAREST_MIPMAP_LINEAR:
       return { minFilter: "nearest", mipmapFilter: "linear" };
-    case 9987:
+    case GLEnum.LINEAR_MIPMAP_LINEAR:
       return { minFilter: "linear", mipmapFilter: "linear" };
     default:
       return {};
@@ -171,7 +204,8 @@ function parsePBRMaterial(device, material, attributes, options) {
   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 == null ? void 0 : options.pbrDebug) {
@@ -185,113 +219,713 @@ function parsePBRMaterial(device, material, attributes, options) {
     parsedMaterial.defines["HAS_TANGENTS"] = true;
   if (attributes["TEXCOORD_0"])
     parsedMaterial.defines["HAS_UV"] = true;
+  if (attributes["JOINTS_0"] && attributes["WEIGHTS_0"])
+    parsedMaterial.defines["HAS_SKIN"] = true;
+  if (attributes["COLOR_0"])
+    parsedMaterial.defines["HAS_COLORS"] = true;
   if (options == null ? void 0 : options.imageBasedLightingEnvironment)
     parsedMaterial.defines["USE_IBL"] = true;
   if (options == null ? void 0 : 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) {
+  var _a;
+  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 || ((_a = material.extensions) == null ? void 0 : _a.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) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t;
+  const uvDependentTextureSlots = [];
+  if ((_a = material.pbrMetallicRoughness) == null ? void 0 : _a.baseColorTexture) {
+    uvDependentTextureSlots.push("baseColorTexture");
+  }
+  if ((_b = material.pbrMetallicRoughness) == null ? void 0 : _b.metallicRoughnessTexture) {
+    uvDependentTextureSlots.push("metallicRoughnessTexture");
+  }
+  if (material.normalTexture) {
+    uvDependentTextureSlots.push("normalTexture");
+  }
+  if (material.occlusionTexture) {
+    uvDependentTextureSlots.push("occlusionTexture");
+  }
+  if (material.emissiveTexture) {
+    uvDependentTextureSlots.push("emissiveTexture");
+  }
+  if ((_d = (_c = material.extensions) == null ? void 0 : _c.KHR_materials_specular) == null ? void 0 : _d.specularTexture) {
+    uvDependentTextureSlots.push("KHR_materials_specular.specularTexture");
+  }
+  if ((_f = (_e = material.extensions) == null ? void 0 : _e.KHR_materials_specular) == null ? void 0 : _f.specularColorTexture) {
+    uvDependentTextureSlots.push("KHR_materials_specular.specularColorTexture");
+  }
+  if ((_h = (_g = material.extensions) == null ? void 0 : _g.KHR_materials_transmission) == null ? void 0 : _h.transmissionTexture) {
+    uvDependentTextureSlots.push("KHR_materials_transmission.transmissionTexture");
+  }
+  if ((_j = (_i = material.extensions) == null ? void 0 : _i.KHR_materials_clearcoat) == null ? void 0 : _j.clearcoatTexture) {
+    uvDependentTextureSlots.push("KHR_materials_clearcoat.clearcoatTexture");
+  }
+  if ((_l = (_k = material.extensions) == null ? void 0 : _k.KHR_materials_clearcoat) == null ? void 0 : _l.clearcoatRoughnessTexture) {
+    uvDependentTextureSlots.push("KHR_materials_clearcoat.clearcoatRoughnessTexture");
+  }
+  if ((_n = (_m = material.extensions) == null ? void 0 : _m.KHR_materials_sheen) == null ? void 0 : _n.sheenColorTexture) {
+    uvDependentTextureSlots.push("KHR_materials_sheen.sheenColorTexture");
+  }
+  if ((_p = (_o = material.extensions) == null ? void 0 : _o.KHR_materials_sheen) == null ? void 0 : _p.sheenRoughnessTexture) {
+    uvDependentTextureSlots.push("KHR_materials_sheen.sheenRoughnessTexture");
+  }
+  if ((_r = (_q = material.extensions) == null ? void 0 : _q.KHR_materials_iridescence) == null ? void 0 : _r.iridescenceTexture) {
+    uvDependentTextureSlots.push("KHR_materials_iridescence.iridescenceTexture");
+  }
+  if ((_t = (_s = material.extensions) == null ? void 0 : _s.KHR_materials_anisotropy) == null ? void 0 : _t.anisotropyTexture) {
+    uvDependentTextureSlots.push("KHR_materials_anisotropy.anisotropyTexture");
+  }
+  return uvDependentTextureSlots;
+}
+function parseMaterial(device, material, parsedMaterial, gltf) {
+  var _a;
+  parsedMaterial.uniforms.unlit = Boolean(material.unlit || ((_a = material.extensions) == null ? void 0 : _a.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 = 1 } = material.normalTexture;
     parsedMaterial.uniforms.normalScale = scale;
   }
   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"] = 32774;
-      parsedMaterial.glParameters["blendFunc"] = [
-        770,
-        771,
-        1,
-        771
-      ];
+      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"] = GLEnum.FUNC_ADD;
+  parsedMaterial.glParameters["blendFunc"] = [
+    GLEnum.SRC_ALPHA,
+    GLEnum.ONE_MINUS_SRC_ALPHA,
+    GLEnum.ONE,
+    GLEnum.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"] = GLEnum.FUNC_ADD;
+  parsedMaterial.glParameters["blendFunc"] = [
+    GLEnum.ONE,
+    GLEnum.ONE_MINUS_SRC_ALPHA,
+    GLEnum.ONE,
+    GLEnum.ONE_MINUS_SRC_ALPHA
+  ];
+}
+function parsePbrMetallicRoughness(device, pbrMetallicRoughness, parsedMaterial, gltf) {
   if (pbrMetallicRoughness.baseColorTexture) {
-    addTexture(device, pbrMetallicRoughness.baseColorTexture, "pbr_baseColorSampler", "HAS_BASECOLORMAP", parsedMaterial);
+    addTexture(device, pbrMetallicRoughness.baseColorTexture, "pbr_baseColorSampler", parsedMaterial, {
+      featureOptions: {
+        define: "HAS_BASECOLORMAP",
+        enabledUniformName: "baseColorMapEnabled"
+      },
+      gltf
+    });
   }
   parsedMaterial.uniforms.baseColorFactor = pbrMetallicRoughness.baseColorFactor || [1, 1, 1, 1];
   if (pbrMetallicRoughness.metallicRoughnessTexture) {
-    addTexture(device, pbrMetallicRoughness.metallicRoughnessTexture, "pbr_metallicRoughnessSampler", "HAS_METALROUGHNESSMAP", parsedMaterial);
+    addTexture(device, pbrMetallicRoughness.metallicRoughnessTexture, "pbr_metallicRoughnessSampler", 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) {
-  var _a;
-  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 == null ? void 0 : 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 == null ? void 0 : extension.emissiveStrength) !== void 0) {
+    parsedMaterial.uniforms.emissiveStrength = extension.emissiveStrength;
+  }
+}
+function addTexture(device, gltfTexture, uniformName, parsedMaterial, textureParseOptions = {}) {
+  var _a, _b, _c;
+  const { featureOptions = {}, gltf } = textureParseOptions;
+  const { define, enabledUniformName } = featureOptions;
+  const resolvedTextureInfo = resolveTextureInfo(gltfTexture, gltf);
+  const image = (_b = (_a = resolvedTextureInfo.texture) == null ? void 0 : _a.source) == null ? void 0 : _b.image;
+  if (!image) {
+    import_core.log.warn(`Skipping unresolved glTF texture for ${String(uniformName)}`)();
+    return;
   }
   const gltfSampler = {
     wrapS: 10497,
     // default REPEAT S (U) wrapping mode.
     wrapT: 10497,
     // default REPEAT T (V) wrapping mode.
-    ...(_a = gltfTexture == null ? void 0 : gltfTexture.texture) == null ? void 0 : _a.sampler
+    minFilter: 9729,
+    // default LINEAR filtering
+    magFilter: 9729,
+    // default LINEAR filtering
+    ...(_c = resolvedTextureInfo == null ? void 0 : resolvedTextureInfo.texture) == null ? void 0 : _c.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 == null ? 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) {
+  var _a, _b;
+  let levels;
+  if (Array.isArray(image.data) && ((_a = image.data[0]) == null ? void 0 : _a.data)) {
+    levels = image.data;
+  } else if ("mipmaps" in image && Array.isArray(image.mipmaps)) {
+    levels = image.mipmaps;
+  } else {
+    levels = [];
+  }
+  if (levels.length === 0 || !((_b = levels[0]) == null ? void 0 : _b.data)) {
+    import_core.log.warn("createCompressedTexture: compressed image has no valid mip levels, creating fallback")();
+    return createCompressedTextureFallback(device, baseOptions);
+  }
+  const baseLevel = levels[0];
+  const baseWidth = baseLevel.width ?? image.width ?? 0;
+  const baseHeight = baseLevel.height ?? image.height ?? 0;
+  if (baseWidth <= 0 || baseHeight <= 0) {
+    import_core.log.warn("createCompressedTexture: base level has invalid dimensions, creating fallback")();
+    return createCompressedTextureFallback(device, baseOptions);
+  }
+  const format = resolveCompressedTextureFormat(baseLevel);
+  if (!format) {
+    import_core.log.warn("createCompressedTexture: compressed image has no textureFormat, creating fallback")();
+    return createCompressedTextureFallback(device, baseOptions);
+  }
+  const maxMipLevels = getMaxCompressedMipLevels(baseWidth, baseHeight, format);
+  const levelLimit = Math.min(levels.length, maxMipLevels);
+  let validLevelCount = 1;
+  for (let i = 1; i < levelLimit; i++) {
+    const level = levels[i];
+    if (!level.data || level.width <= 0 || level.height <= 0) {
+      import_core.log.warn(`createCompressedTexture: mip level ${i} has invalid data/dimensions, truncating`)();
+      break;
+    }
+    const levelFormat = resolveCompressedTextureFormat(level);
+    if (levelFormat && levelFormat !== format) {
+      import_core.log.warn(`createCompressedTexture: mip level ${i} format '${levelFormat}' differs from base '${format}', truncating`)();
+      break;
+    }
+    const expectedW = Math.max(1, baseWidth >> i);
+    const expectedH = Math.max(1, baseHeight >> i);
+    if (level.width !== expectedW || level.height !== expectedH) {
+      import_core.log.warn(`createCompressedTexture: mip level ${i} dimensions ${level.width}x${level.height} don't match expected ${expectedW}x${expectedH}, truncating`)();
+      break;
+    }
+    validLevelCount++;
+  }
+  const texture = device.createTexture({
+    ...baseOptions,
+    format,
+    usage: import_core.Texture.TEXTURE | import_core.Texture.COPY_DST,
+    width: baseWidth,
+    height: baseHeight,
+    mipLevels: validLevelCount,
+    data: baseLevel.data
+  });
+  for (let i = 1; i < validLevelCount; i++) {
+    texture.writeData(levels[i].data, {
+      width: levels[i].width,
+      height: levels[i].height,
+      mipLevel: i
+    });
+  }
+  return texture;
+}
+
+// dist/parsers/parse-gltf-lights.js
+var import_core2 = require("@math.gl/core");
+var GLTF_COLOR_FACTOR = 255;
+function parseGLTFLights(gltf) {
+  var _a, _b, _c, _d;
+  const lightDefs = (
+    // `postProcessGLTF()` moves KHR_lights_punctual into `gltf.lights`.
+    gltf.lights || ((_b = (_a = gltf.extensions) == null ? void 0 : _a["KHR_lights_punctual"]) == null ? void 0 : _b["lights"])
+  );
+  if (!lightDefs || !Array.isArray(lightDefs) || lightDefs.length === 0) {
+    return [];
+  }
+  const lights = [];
+  const parentNodeById = createParentNodeMap(gltf.nodes || []);
+  const worldMatrixByNodeId = /* @__PURE__ */ new Map();
+  for (const node of gltf.nodes || []) {
+    const lightIndex = node.light ?? ((_d = (_c = node.extensions) == null ? void 0 : _c.KHR_lights_punctual) == null ? void 0 : _d.light);
+    if (typeof lightIndex !== "number") {
+      continue;
+    }
+    const gltfLight = lightDefs[lightIndex];
+    if (!gltfLight) {
+      continue;
+    }
+    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(worldMatrix, color, intensity));
+        break;
+      case "point":
+        lights.push(parsePointLight(worldMatrix, color, intensity, range));
+        break;
+      case "spot":
+        lights.push(parseSpotLight(worldMatrix, color, intensity, range, gltfLight.spot));
+        break;
+      default:
+        break;
+    }
+  }
+  return lights;
+}
+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)];
+  }
+  return {
+    type: "point",
+    position,
+    color,
+    intensity,
+    attenuation
+  };
+}
+function parseDirectionalLight(worldMatrix, color, intensity) {
+  const direction = getLightDirection(worldMatrix);
+  return {
+    type: "directional",
+    direction,
+    color,
+    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 import_core2.Matrix4(getNodeWorldMatrix(parentNode, parentNodeById, worldMatrixByNodeId)).multiplyRight(localMatrix) : localMatrix;
+  worldMatrixByNodeId.set(node.id, worldMatrix);
+  return worldMatrix;
+}
+function getNodeLocalMatrix(node) {
+  if (node.matrix) {
+    return new import_core2.Matrix4(node.matrix);
+  }
+  const matrix = new import_core2.Matrix4();
+  if (node.translation) {
+    matrix.translate(node.translation);
+  }
+  if (node.rotation) {
+    matrix.multiplyRight(new import_core2.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]);
+}
 
 // dist/parsers/parse-gltf.js
-var import_engine3 = require("@luma.gl/engine");
-var import_core3 = require("@math.gl/core");
+var import_engine4 = require("@luma.gl/engine");
+var import_shadertools2 = require("@luma.gl/shadertools");
 
 // dist/webgl-to-webgpu/convert-webgl-topology.js
-var GLEnum;
-(function(GLEnum2) {
-  GLEnum2[GLEnum2["POINTS"] = 0] = "POINTS";
-  GLEnum2[GLEnum2["LINES"] = 1] = "LINES";
-  GLEnum2[GLEnum2["LINE_LOOP"] = 2] = "LINE_LOOP";
-  GLEnum2[GLEnum2["LINE_STRIP"] = 3] = "LINE_STRIP";
-  GLEnum2[GLEnum2["TRIANGLES"] = 4] = "TRIANGLES";
-  GLEnum2[GLEnum2["TRIANGLE_STRIP"] = 5] = "TRIANGLE_STRIP";
-  GLEnum2[GLEnum2["TRIANGLE_FAN"] = 6] = "TRIANGLE_FAN";
-})(GLEnum || (GLEnum = {}));
 function convertGLDrawModeToTopology(drawMode) {
   switch (drawMode) {
     case GLEnum.POINTS:
@@ -310,56 +944,95 @@ function convertGLDrawModeToTopology(drawMode) {
 }
 
 // dist/gltf/create-gltf-model.js
-var import_core2 = require("@luma.gl/core");
-var import_shadertools = require("@luma.gl/shadertools");
+var import_core3 = require("@luma.gl/core");
 var import_engine2 = require("@luma.gl/engine");
+var import_shadertools = require("@luma.gl/shadertools");
+var import_engine3 = require("@luma.gl/engine");
 var SHADER = (
   /* WGSL */
   `
-layout(0) positions: vec4; // in vec4 POSITION;
-
-  #ifdef HAS_NORMALS
-    in vec4 normals; // in vec4 NORMAL;
-  #endif
-
-  #ifdef HAS_TANGENTS
-    in vec4 TANGENT;
-  #endif
+struct VertexInputs {
+  @location(0) positions: vec3f,
+#ifdef HAS_NORMALS
+  @location(1) normals: vec3f,
+#endif
+#ifdef HAS_TANGENTS
+  @location(2) TANGENT: vec4f,
+#endif
+#ifdef HAS_UV
+  @location(3) texCoords: vec2f,
+#endif
+#ifdef HAS_SKIN
+  @location(4) JOINTS_0: vec4u,
+  @location(5) WEIGHTS_0: vec4f,
+#endif
+};
 
-  #ifdef HAS_UV
-    // in vec2 TEXCOORD_0;
-    in vec2 texCoords;
-  #endif
+struct FragmentInputs {
+  @builtin(position) position: vec4f,
+  @location(0) pbrPosition: vec3f,
+  @location(1) pbrUV: vec2f,
+  @location(2) pbrNormal: vec3f,
+#ifdef HAS_TANGENTS
+  @location(3) pbrTangent: vec4f,
+#endif
+};
 
 @vertex
-  void main(void) {
-    vec4 _NORMAL = vec4(0.);
-    vec4 _TANGENT = vec4(0.);
-    vec2 _TEXCOORD_0 = vec2(0.);
+fn vertexMain(inputs: VertexInputs) -> FragmentInputs {
+  var outputs: FragmentInputs;
+  var position = vec4f(inputs.positions, 1.0);
+  var normal = vec3f(0.0, 0.0, 1.0);
+  var tangent = vec4f(1.0, 0.0, 0.0, 1.0);
+  var uv = vec2f(0.0, 0.0);
 
-    #ifdef HAS_NORMALS
-      _NORMAL = normals;
-    #endif
+#ifdef HAS_NORMALS
+  normal = inputs.normals;
+#endif
+#ifdef HAS_UV
+  uv = inputs.texCoords;
+#endif
+#ifdef HAS_TANGENTS
+  tangent = inputs.TANGENT;
+#endif
+#ifdef HAS_SKIN
+  let skinMatrix = getSkinMatrix(inputs.WEIGHTS_0, inputs.JOINTS_0);
+  position = skinMatrix * position;
+  normal = normalize((skinMatrix * vec4f(normal, 0.0)).xyz);
+#ifdef HAS_TANGENTS
+  tangent = vec4f(normalize((skinMatrix * vec4f(tangent.xyz, 0.0)).xyz), tangent.w);
+#endif
+#endif
 
-    #ifdef HAS_TANGENTS
-      _TANGENT = TANGENT;
-    #endif
+  let worldPosition = pbrProjection.modelMatrix * position;
 
-    #ifdef HAS_UV
-      _TEXCOORD_0 = texCoords;
-    #endif
+#ifdef HAS_NORMALS
+  normal = normalize((pbrProjection.normalMatrix * vec4f(normal, 0.0)).xyz);
+#endif
+#ifdef HAS_TANGENTS
+  let worldTangent = normalize((pbrProjection.modelMatrix * vec4f(tangent.xyz, 0.0)).xyz);
+  outputs.pbrTangent = vec4f(worldTangent, tangent.w);
+#endif
 
-    pbr_setPositionNormalTangentUV(positions, _NORMAL, _TANGENT, _TEXCOORD_0);
-    gl_Position = u_MVPMatrix * positions;
-  }
+  outputs.position = pbrProjection.modelViewProjectionMatrix * position;
+  outputs.pbrPosition = worldPosition.xyz / worldPosition.w;
+  outputs.pbrUV = uv;
+  outputs.pbrNormal = normal;
+  return outputs;
+}
 
 @fragment
-  out vec4 fragmentColor;
-
-  void main(void) {
-    vec3 pos = pbr_vPosition;
-    fragmentColor = pbr_filterColor(vec4(1.0));
-  }
+fn fragmentMain(inputs: FragmentInputs) -> @location(0) vec4f {
+  fragmentInputs.pbr_vPosition = inputs.pbrPosition;
+  fragmentInputs.pbr_vUV = inputs.pbrUV;
+  fragmentInputs.pbr_vNormal = inputs.pbrNormal;
+#ifdef HAS_TANGENTS
+  let tangent = normalize(inputs.pbrTangent.xyz);
+  let bitangent = normalize(cross(inputs.pbrNormal, tangent)) * inputs.pbrTangent.w;
+  fragmentInputs.pbr_vTBN = mat3x3f(tangent, bitangent, inputs.pbrNormal);
+#endif
+  return pbr_filterColor(vec4f(1.0));
+}
 `
 );
 var vs = (
@@ -383,6 +1056,11 @@ var vs = (
     in vec2 texCoords;
   #endif
 
+  #ifdef HAS_SKIN
+    in uvec4 JOINTS_0;
+    in vec4 WEIGHTS_0;
+  #endif
+
   void main(void) {
     vec4 _NORMAL = vec4(0.);
     vec4 _TANGENT = vec4(0.);
@@ -400,8 +1078,17 @@ var vs = (
       _TEXCOORD_0 = texCoords;
     #endif
 
-    pbr_setPositionNormalTangentUV(positions, _NORMAL, _TANGENT, _TEXCOORD_0);
-    gl_Position = pbrProjection.modelViewProjectionMatrix * positions;
+    vec4 pos = positions;
+
+    #ifdef HAS_SKIN
+      mat4 skinMat = getSkinMatrix(WEIGHTS_0, JOINTS_0);
+      pos = skinMat * pos;
+      _NORMAL = skinMat * _NORMAL;
+      _TANGENT = vec4((skinMat * vec4(_TANGENT.xyz, 0.)).xyz, _TANGENT.w);
+    #endif
+
+    pbr_setPositionNormalTangentUV(pos, _NORMAL, _TANGENT, _TEXCOORD_0);
+    gl_Position = pbrProjection.modelViewProjectionMatrix * pos;
   }
 `
 );
@@ -416,9 +1103,24 @@ var fs = (
   }
 `
 );
+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_core2.log.info(4, "createGLTFModel defines: ", parsedPPBRMaterial.defines)();
+  import_core3.log.info(4, "createGLTFModel defines: ", parsedPPBRMaterial.defines)();
   const managedResources = [];
   const parameters = {
     depthWriteEnabled: true,
@@ -434,20 +1136,53 @@ function createGLTFModel(device, options) {
     geometry,
     topology: geometry.topology,
     vertexCount,
-    modules: [import_shadertools.pbrMaterial],
+    modules: [import_shadertools.pbrMaterial, import_shadertools.skin],
     ...modelOptions,
     defines: { ...parsedPPBRMaterial.defines, ...modelOptions.defines },
     parameters: { ...parameters, ...parsedPPBRMaterial.parameters, ...modelOptions.parameters }
   };
-  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 module2 of modules) {
+    for (const uniformName of Object.keys(module2.uniformTypes || {})) {
+      propertyToModuleNameMap.set(uniformName, module2.name);
+    }
+    for (const binding of module2.bindingLayout || []) {
+      propertyToModuleNameMap.set(binding.name, module2.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;
 }
 
 // dist/parsers/parse-gltf.js
@@ -458,73 +1193,103 @@ var defaultOptions = {
   lights: true,
   useTangents: false
 };
-function parseGLTF(device, gltf, options_ = {}) {
-  const options = { ...defaultOptions, ...options_ };
-  const sceneNodes = gltf.scenes.map((gltfScene) => createScene(device, gltfScene, gltf.nodes, options));
-  return sceneNodes;
-}
-function createScene(device, gltfScene, gltfNodes, options) {
-  const gltfSceneNodes = gltfScene.nodes || [];
-  const nodes = gltfSceneNodes.map((node) => createNode(device, node, gltfNodes, options));
-  const sceneNode = new import_engine3.GroupNode({
-    id: gltfScene.name || gltfScene.id,
-    children: nodes
+function parseGLTF(device, gltf, options = {}) {
+  const combinedOptions = { ...defaultOptions, ...options };
+  const 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
+  }));
+  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 import_core3.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 createPrimitive(device, gltfPrimitive, i, gltfMesh, options) {
-  const id = gltfPrimitive.name || `${gltfMesh.name || gltfMesh.id}-primitive-${i}`;
+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 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
@@ -541,42 +1306,41 @@ function createGeometry(id, gltfPrimitive, topology) {
     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}`;
+}
 
 // dist/gltf/gltf-animator.js
 var import_core6 = require("@luma.gl/core");
-var import_core7 = require("@math.gl/core");
 
 // dist/gltf/animations/interpolate.js
 var import_core4 = require("@luma.gl/core");
 var import_core5 = require("@math.gl/core");
-var scratchQuaternion = new import_core5.Quaternion();
+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_core4.log.warn(`Bad animation path ${path}`)();
-    }
-  }
   const previousTime = input[previousIndex];
   const nextTime = input[nextIndex];
   switch (interpolation) {
@@ -606,68 +1370,73 @@ function interpolate(time, { input, interpolation, output }, target, path) {
   }
 }
 function linearInterpolate(target, path, start, stop, ratio) {
-  if (!target[path]) {
-    throw new Error();
-  }
   if (path === "rotation") {
-    scratchQuaternion.slerp({ start, target: stop, ratio });
-    for (let i = 0; i < scratchQuaternion.length; i++) {
-      target[path][i] = scratchQuaternion[i];
-    }
+    updateTargetPath(target, path, new import_core5.Quaternion().slerp({ start, target: stop, ratio }));
   } else {
+    const newVal = [];
     for (let i = 0; i < start.length; i++) {
-      target[path][i] = ratio * stop[i] + (1 - ratio) * start[i];
+      newVal[i] = ratio * stop[i] + (1 - ratio) * start[i];
     }
+    updateTargetPath(target, path, newVal);
   }
 }
 function cubicsplineInterpolate(target, path, { p0, outTangent0, inTangent1, p1, tDiff, ratio: t }) {
-  if (!target[path]) {
-    throw new Error();
-  }
-  for (let i = 0; i < target[path].length; i++) {
+  const newVal = [];
+  for (let i = 0; i < p0.length; i++) {
     const m0 = outTangent0[i] * tDiff;
     const m1 = inTangent1[i] * tDiff;
-    target[path][i] = (2 * Math.pow(t, 3) - 3 * Math.pow(t, 2) + 1) * p0[i] + (Math.pow(t, 3) - 2 * Math.pow(t, 2) + t) * m0 + (-2 * Math.pow(t, 3) + 3 * Math.pow(t, 2)) * p1[i] + (Math.pow(t, 3) - Math.pow(t, 2)) * m1;
+    newVal[i] = (2 * Math.pow(t, 3) - 3 * Math.pow(t, 2) + 1) * p0[i] + (Math.pow(t, 3) - 2 * Math.pow(t, 2) + t) * m0 + (-2 * Math.pow(t, 3) + 3 * Math.pow(t, 2)) * p1[i] + (Math.pow(t, 3) - Math.pow(t, 2)) * m1;
   }
+  updateTargetPath(target, path, newVal);
 }
 function stepInterpolate(target, path, value) {
-  if (!target[path]) {
-    throw new Error();
-  }
-  for (let i = 0; i < value.length; i++) {
-    target[path][i] = value[i];
-  }
+  updateTargetPath(target, path, value);
 }
 
 // dist/gltf/gltf-animator.js
 var GLTFSingleAnimator = class {
+  /** Animation definition being played. */
   animation;
+  /** Target scenegraph lookup table. */
+  gltfNodeIdToNodeMap;
+  /** Playback start time in seconds. */
   startTime = 0;
+  /** Whether playback is currently enabled. */
   playing = true;
+  /** Playback speed multiplier. */
   speed = 1;
+  /** Creates a single-animation controller. */
   constructor(props) {
     this.animation = props.animation;
+    this.gltfNodeIdToNodeMap = props.gltfNodeIdToNodeMap;
     this.animation.name ||= "unnamed";
     Object.assign(this, props);
   }
+  /** Advances the animation to the supplied wall-clock time in milliseconds. */
   setTime(timeMs) {
     if (!this.playing) {
       return;
     }
     const absTime = timeMs / 1e3;
     const time = (absTime - this.startTime) * this.speed;
-    this.animation.channels.forEach(({ sampler, target, path }) => {
-      interpolate(time, sampler, target, path);
-      applyTranslationRotationScale(target, target._node);
+    this.animation.channels.forEach(({ sampler, targetNodeId, path }) => {
+      const targetNode = this.gltfNodeIdToNodeMap.get(targetNodeId);
+      if (!targetNode) {
+        throw new Error(`Cannot find animation target node ${targetNodeId}`);
+      }
+      interpolate(time, sampler, targetNode, path);
     });
   }
 };
 var GLTFAnimator = class {
+  /** Individual animation controllers. */
   animations;
+  /** Creates an animator for the supplied glTF scenegraph. */
   constructor(props) {
     this.animations = props.animations.map((animation, index) => {
       const name = animation.name || `Animation-${index}`;
       return new GLTFSingleAnimator({
+        gltfNodeIdToNodeMap: props.gltfNodeIdToNodeMap,
         animation: { name, channels: animation.channels }
       });
     });
@@ -677,27 +1446,18 @@ var GLTFAnimator = class {
     import_core6.log.warn("GLTFAnimator#animate is deprecated. Use GLTFAnimator#setTime instead")();
     this.setTime(time);
   }
+  /** Advances every animation to the supplied wall-clock time in milliseconds. */
   setTime(time) {
     this.animations.forEach((animation) => animation.setTime(time));
   }
+  /** Returns the per-animation controllers managed by this animator. */
   getAnimations() {
     return this.animations;
   }
 };
-var scratchMatrix = new import_core7.Matrix4();
-function applyTranslationRotationScale(gltfNode, node) {
-  node.matrix.identity();
-  if (gltfNode.translation) {
-    node.matrix.translate(gltfNode.translation);
-  }
-  if (gltfNode.rotation) {
-    const rotationMatrix = scratchMatrix.fromQuaternion(gltfNode.rotation);
-    node.matrix.multiplyRight(rotationMatrix);
-  }
-  if (gltfNode.scale) {
-    node.matrix.scale(gltfNode.scale);
-  }
-}
+
+// dist/parsers/parse-gltf-animations.js
+var import_core7 = require("@luma.gl/core");
 
 // dist/webgl-to-webgpu/convert-webgl-attribute.js
 var ATTRIBUTE_TYPE_TO_COMPONENTS = {
@@ -730,61 +1490,327 @@ function accessorToTypedArray(accessor) {
 // dist/parsers/parse-gltf-animations.js
 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 path;
+}
+function accessorToJsArray1D(accessor, accessorCache) {
+  if (accessorCache.has(accessor)) {
+    return accessorCache.get(accessor);
+  }
+  const { typedArray: array, components } = accessorToTypedArray(accessor);
+  assert(components === 1, "accessorToJsArray1D must have exactly 1 component");
+  const result = Array.from(array);
+  accessorCache.set(accessor, result);
+  return result;
+}
+function accessorToJsArray2D(accessor, accessorCache) {
+  if (accessorCache.has(accessor)) {
+    return accessorCache.get(accessor);
+  }
+  const { typedArray: array, components } = accessorToTypedArray(accessor);
+  assert(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 assert(condition, message) {
+  if (!condition) {
+    throw new Error(message);
   }
-  return accessor._animation;
 }
 
-// dist/utils/deep-copy.js
-function deepCopy(object) {
-  if (ArrayBuffer.isView(object) || object instanceof ArrayBuffer || object instanceof ImageBitmap) {
-    return object;
+// dist/gltf/gltf-extension-support.js
+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."
   }
-  if (Array.isArray(object)) {
-    return object.map(deepCopy);
+};
+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 new Map(extensionSupportEntries);
+}
+function collectGLTFExtensionNames(gltf) {
+  var _a;
+  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 (((_a = gltfWithRemovedExtensions.lights) == null ? void 0 : _a.length) || gltf.nodes.some((node) => "light" in node)) {
+    extensionNames.add("KHR_lights_punctual");
   }
-  if (object && typeof object === "object") {
-    const result = {};
-    for (const key in object) {
-      result[key] = deepCopy(object[key]);
-    }
-    return result;
+  if (gltf.materials.some((material) => {
+    var _a2;
+    const gltfMaterial = material;
+    return gltfMaterial.unlit || ((_a2 = gltfMaterial.extensions) == null ? void 0 : _a2.KHR_materials_unlit);
+  })) {
+    extensionNames.add("KHR_materials_unlit");
+  }
+  return extensionNames;
+}
+function addExtensionNames(extensionNames, newExtensionNames = []) {
+  for (const extensionName of newExtensionNames) {
+    extensionNames.add(extensionName);
   }
-  return object;
 }
 
 // dist/gltf/create-scenegraph-from-gltf.js
 function createScenegraphsFromGLTF(device, gltf, options) {
-  gltf = deepCopy(gltf);
-  const scenes = parseGLTF(device, gltf, options);
+  const { scenes, materials, gltfMeshIdToNodeMap, gltfNodeIdToNodeMap, gltfNodeIndexToNodeMap } = parseGLTF(device, gltf, options);
   const animations = parseGLTFAnimations(gltf);
-  const animator = new GLTFAnimator({ animations });
-  return { scenes, animator };
+  const animator = new GLTFAnimator({ animations, gltfNodeIdToNodeMap });
+  const lights = parseGLTFLights(gltf);
+  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);
 }
 //# sourceMappingURL=index.cjs.map