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

package/dist/index.cjs

@@ -22,6 +22,7 @@ var dist_exports = {};
 __export(dist_exports, {
   GLTFAnimator: () => GLTFAnimator,
   createScenegraphsFromGLTF: () => createScenegraphsFromGLTF,
+  getGLTFExtensionSupport: () => getGLTFExtensionSupport,
   loadPBREnvironment: () => loadPBREnvironment,
   parseGLTFLights: () => parseGLTFLights,
   parsePBRMaterial: () => parsePBRMaterial
@@ -32,6 +33,7 @@ module.exports = __toCommonJS(dist_exports);
 var import_engine = require("@luma.gl/engine");
 var import_textures = require("@loaders.gl/textures");
 function loadPBREnvironment(device, props) {
+  const specularMipLevels = props.specularMipLevels ?? 1;
   const brdfLutTexture = new import_engine.DynamicTexture(device, {
     id: "brdfLUT",
     sampler: {
@@ -45,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",
@@ -55,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",
@@ -76,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.DynamicTexture(device, {
     id,
     dimension: "cube",
     mipmaps: false,
     sampler,
-    // @ts-expect-error
     data
   });
 }
 
 // dist/parsers/parse-pbr-material.js
 var import_core = require("@luma.gl/core");
-var import_constants2 = require("@luma.gl/constants");
+
+// 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),
@@ -108,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;
@@ -120,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;
@@ -130,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 {};
@@ -172,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) {
@@ -195,69 +228,419 @@ function parsePBRMaterial(device, material, attributes, options) {
   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;
+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.
@@ -267,10 +650,10 @@ function addTexture(device, gltfTexture, uniformName, define, parsedMaterial) {
     // default LINEAR filtering
     magFilter: 9729,
     // default LINEAR filtering
-    ...(_a = gltfTexture == null ? void 0 : gltfTexture.texture) == null ? void 0 : _a.sampler
+    ...(_c = resolvedTextureInfo == null ? void 0 : resolvedTextureInfo.texture) == null ? void 0 : _c.sampler
   };
   const baseOptions = {
-    id: gltfTexture.uniformName || gltfTexture.id,
+    id: resolvedTextureInfo.uniformName || resolvedTextureInfo.id,
     sampler: convertSampler(gltfSampler)
   };
   let texture;
@@ -288,8 +671,34 @@ function addTexture(device, gltfTexture, uniformName, define, parsedMaterial) {
   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,
@@ -383,6 +792,7 @@ function createCompressedTexture(device, image, baseOptions) {
 
 // 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 = (
@@ -393,6 +803,8 @@ function parseGLTFLights(gltf) {
     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") {
@@ -402,18 +814,19 @@ function parseGLTFLights(gltf) {
     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;
@@ -421,8 +834,11 @@ function parseGLTFLights(gltf) {
   }
   return lights;
 }
-function parsePointLight(node, color, intensity, range) {
-  const position = getNodePosition(node);
+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)];
@@ -435,8 +851,8 @@ function parsePointLight(node, color, intensity, range) {
     attenuation
   };
 }
-function parseDirectionalLight(node, color, intensity) {
-  const direction = getNodeDirection(node);
+function parseDirectionalLight(worldMatrix, color, intensity) {
+  const direction = getLightDirection(worldMatrix);
   return {
     type: "directional",
     direction,
@@ -444,39 +860,72 @@ function parseDirectionalLight(node, color, intensity) {
     intensity
   };
 }
-function getNodePosition(node) {
-  if (node.matrix) {
-    return new import_core2.Matrix4(node.matrix).transformAsPoint([0, 0, 0]);
+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)];
   }
-  if (node.translation) {
-    return [...node.translation];
+  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;
   }
-  return [0, 0, 0];
+  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 getNodeDirection(node) {
+function getNodeLocalMatrix(node) {
   if (node.matrix) {
-    return new import_core2.Matrix4(node.matrix).transformDirection([0, 0, -1]);
+    return new import_core2.Matrix4(node.matrix);
+  }
+  const matrix = new import_core2.Matrix4();
+  if (node.translation) {
+    matrix.translate(node.translation);
   }
   if (node.rotation) {
-    return new import_core2.Matrix4().fromQuaternion(node.rotation).transformDirection([0, 0, -1]);
+    matrix.multiplyRight(new import_core2.Matrix4().fromQuaternion(node.rotation));
+  }
+  if (node.scale) {
+    matrix.scale(node.scale);
   }
-  return [0, 0, -1];
+  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_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:
@@ -496,8 +945,9 @@ function convertGLDrawModeToTopology(drawMode) {
 
 // dist/gltf/create-gltf-model.js
 var import_core3 = require("@luma.gl/core");
-var import_shadertools = require("@luma.gl/shadertools");
 var import_engine2 = require("@luma.gl/engine");
+var import_shadertools = require("@luma.gl/shadertools");
+var import_engine3 = require("@luma.gl/engine");
 var SHADER = (
   /* WGSL */
   `
@@ -653,6 +1103,21 @@ 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_core3.log.info(4, "createGLTFModel defines: ", parsedPPBRMaterial.defines)();
@@ -676,15 +1141,48 @@ function createGLTFModel(device, options) {
     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
@@ -697,9 +1195,23 @@ var defaultOptions = {
 };
 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]);
+  });
   const gltfMeshIdToNodeMap = /* @__PURE__ */ new Map();
   gltf.meshes.forEach((gltfMesh, idx) => {
-    const newMesh = createNodeForGLTFMesh(device, gltfMesh, combinedOptions);
+    const newMesh = createNodeForGLTFMesh(device, gltfMesh, gltf, gltfMaterialIdToMaterialMap, combinedOptions);
     gltfMeshIdToNodeMap.set(gltfMesh.id, newMesh);
   });
   const gltfNodeIndexToNodeMap = /* @__PURE__ */ new Map();
@@ -731,15 +1243,15 @@ function parseGLTF(device, gltf, options = {}) {
         throw new Error(`Cannot find child ${id} of scene ${gltfScene.name || gltfScene.id}`);
       return child;
     });
-    return new import_engine3.GroupNode({
+    return new import_engine4.GroupNode({
       id: gltfScene.name || gltfScene.id,
       children
     });
   });
-  return { scenes, gltfMeshIdToNodeMap, gltfNodeIdToNodeMap, gltfNodeIndexToNodeMap };
+  return { scenes, materials, gltfMeshIdToNodeMap, gltfNodeIdToNodeMap, gltfNodeIndexToNodeMap };
 }
 function createNodeForGLTFNode(device, gltfNode, options) {
-  return new import_engine3.GroupNode({
+  return new import_engine4.GroupNode({
     id: gltfNode.name || gltfNode.id,
     children: [],
     matrix: gltfNode.matrix,
@@ -748,24 +1260,36 @@ function createNodeForGLTFNode(device, gltfNode, options) {
     scale: gltfNode.scale
   });
 }
-function createNodeForGLTFMesh(device, gltfMesh, options) {
+function createNodeForGLTFMesh(device, gltfMesh, gltf, gltfMaterialIdToMaterialMap, options) {
   const gltfPrimitives = gltfMesh.primitives || [];
-  const primitives = gltfPrimitives.map((gltfPrimitive, i) => createNodeForGLTFPrimitive(device, gltfPrimitive, i, gltfMesh, options));
-  const mesh = new import_engine3.GroupNode({
+  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, i, gltfMesh, options) {
-  const id = gltfPrimitive.name || `${gltfMesh.name || gltfMesh.id}-primitive-${i}`;
+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
@@ -782,13 +1306,16 @@ 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");
@@ -929,6 +1456,9 @@ var GLTFAnimator = class {
   }
 };
 
+// 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 = {
   SCALAR: 1,
@@ -962,27 +1492,48 @@ function parseGLTFAnimations(gltf) {
   const gltfAnimations = gltf.animations || [];
   const accessorCache1D = /* @__PURE__ */ new Map();
   const accessorCache2D = /* @__PURE__ */ new Map();
-  return gltfAnimations.map((animation, index) => {
+  return gltfAnimations.flatMap((animation, index) => {
     const name = animation.name || `Animation-${index}`;
-    const samplers = animation.samplers.map(({ input, interpolation = "LINEAR", output }) => ({
-      input: accessorToJsArray1D(gltf.accessors[input], accessorCache1D),
-      interpolation,
-      output: accessorToJsArray2D(gltf.accessors[output], accessorCache2D)
-    }));
-    const channels = animation.channels.map(({ sampler, target }) => {
+    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: samplers[sampler],
+        sampler: parsedSampler,
         targetNodeId: targetNode.id,
-        path: target.path
+        path
       };
     });
-    return { name, channels };
+    return channels.length ? [{ name, channels }] : [];
   });
 }
+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);
@@ -998,7 +1549,7 @@ function accessorToJsArray2D(accessor, accessorCache) {
     return accessorCache.get(accessor);
   }
   const { typedArray: array, components } = accessorToTypedArray(accessor);
-  assert(components > 1, "accessorToJsArray2D must have more than 1 component");
+  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)));
@@ -1012,20 +1563,254 @@ function assert(condition, message) {
   }
 }
 
+// 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."
+  }
+};
+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 (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);
+  }
+}
+
 // dist/gltf/create-scenegraph-from-gltf.js
 function createScenegraphsFromGLTF(device, gltf, options) {
-  const { scenes, gltfMeshIdToNodeMap, gltfNodeIdToNodeMap, gltfNodeIndexToNodeMap } = parseGLTF(device, gltf, options);
+  const { scenes, materials, gltfMeshIdToNodeMap, gltfNodeIdToNodeMap, gltfNodeIndexToNodeMap } = parseGLTF(device, gltf, options);
   const animations = parseGLTFAnimations(gltf);
   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