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

package/dist/dist.dev.js

@@ -52,13 +52,6 @@ var __exports__ = (() => {
     }
   });
 
-  // external-global-plugin:@luma.gl/constants
-  var require_constants = __commonJS({
-    "external-global-plugin:@luma.gl/constants"(exports, module) {
-      module.exports = globalThis.luma;
-    }
-  });
-
   // external-global-plugin:@luma.gl/shadertools
   var require_shadertools = __commonJS({
     "external-global-plugin:@luma.gl/shadertools"(exports, module) {
@@ -71,6 +64,7 @@ var __exports__ = (() => {
   __export(bundle_exports, {
     GLTFAnimator: () => GLTFAnimator,
     createScenegraphsFromGLTF: () => createScenegraphsFromGLTF,
+    getGLTFExtensionSupport: () => getGLTFExtensionSupport,
     loadPBREnvironment: () => loadPBREnvironment,
     parseGLTFLights: () => parseGLTFLights,
     parsePBRMaterial: () => parsePBRMaterial
@@ -620,6 +614,7 @@ var __exports__ = (() => {
 
   // src/pbr/pbr-environment.ts
   function loadPBREnvironment(device, props) {
+    const specularMipLevels = props.specularMipLevels ?? 1;
     const brdfLutTexture = new import_engine.DynamicTexture(device, {
       id: "brdfLUT",
       sampler: {
@@ -633,7 +628,9 @@ var __exports__ = (() => {
     });
     const diffuseEnvSampler = makeCube(device, {
       id: "DiffuseEnvSampler",
-      getTextureForFace: (dir) => loadImageTexture(props.getTexUrl("diffuse", dir, 0)),
+      getTextureForFace: (face) => loadImageTexture(
+        props.getTexUrl("diffuse", FACES.indexOf(face), 0)
+      ),
       sampler: {
         addressModeU: "clamp-to-edge",
         addressModeV: "clamp-to-edge",
@@ -643,12 +640,13 @@ var __exports__ = (() => {
     });
     const specularEnvSampler = makeCube(device, {
       id: "SpecularEnvSampler",
-      getTextureForFace: (dir) => {
+      getTextureForFace: (face) => {
         const imageArray = [];
-        for (let lod = 0; lod <= props.specularMipLevels - 1; lod++) {
-          imageArray.push(loadImageTexture(props.getTexUrl("specular", dir, lod)));
+        const direction = FACES.indexOf(face);
+        for (let lod = 0; lod < specularMipLevels; lod++) {
+          imageArray.push(loadImageTexture(props.getTexUrl("specular", direction, lod)));
         }
-        return imageArray;
+        return Promise.all(imageArray);
       },
       sampler: {
         addressModeU: "clamp-to-edge",
@@ -664,32 +662,34 @@ var __exports__ = (() => {
       specularEnvSampler
     };
   }
-  var FACES = [0, 1, 2, 3, 4, 5];
+  var FACES = ["+X", "-X", "+Y", "-Y", "+Z", "-Z"];
   function makeCube(device, {
     id,
     getTextureForFace,
     sampler
   }) {
-    const data = {};
-    FACES.forEach((face) => {
-      data[String(face)] = getTextureForFace(face);
+    const data = Promise.all(
+      FACES.map((face) => getTextureForFace(face))
+    ).then((faceDataArray) => {
+      const cubeData = {};
+      FACES.forEach((face, index) => {
+        cubeData[face] = faceDataArray[index];
+      });
+      return cubeData;
     });
     return new import_engine.DynamicTexture(device, {
       id,
       dimension: "cube",
       mipmaps: false,
       sampler,
-      // @ts-expect-error
       data
     });
   }
 
   // src/parsers/parse-pbr-material.ts
   var import_core = __toESM(require_core(), 1);
-  var import_constants2 = __toESM(require_constants(), 1);
 
   // src/webgl-to-webgpu/convert-webgl-sampler.ts
-  var import_constants = __toESM(require_constants(), 1);
   function convertSampler(gltfSampler) {
     return {
       addressModeU: convertSamplerWrapMode(gltfSampler.wrapS),
@@ -700,11 +700,11 @@ var __exports__ = (() => {
   }
   function convertSamplerWrapMode(mode) {
     switch (mode) {
-      case import_constants.GL.CLAMP_TO_EDGE:
+      case 33071 /* CLAMP_TO_EDGE */:
         return "clamp-to-edge";
-      case import_constants.GL.REPEAT:
+      case 10497 /* REPEAT */:
         return "repeat";
-      case import_constants.GL.MIRRORED_REPEAT:
+      case 33648 /* MIRRORED_REPEAT */:
         return "mirror-repeat";
       default:
         return void 0;
@@ -712,9 +712,9 @@ var __exports__ = (() => {
   }
   function convertSamplerMagFilter(mode) {
     switch (mode) {
-      case import_constants.GL.NEAREST:
+      case 9728 /* NEAREST */:
         return "nearest";
-      case import_constants.GL.LINEAR:
+      case 9729 /* LINEAR */:
         return "linear";
       default:
         return void 0;
@@ -722,17 +722,17 @@ var __exports__ = (() => {
   }
   function convertSamplerMinFilter(mode) {
     switch (mode) {
-      case import_constants.GL.NEAREST:
+      case 9728 /* NEAREST */:
         return { minFilter: "nearest" };
-      case import_constants.GL.LINEAR:
+      case 9729 /* LINEAR */:
         return { minFilter: "linear" };
-      case import_constants.GL.NEAREST_MIPMAP_NEAREST:
+      case 9984 /* NEAREST_MIPMAP_NEAREST */:
         return { minFilter: "nearest", mipmapFilter: "nearest" };
-      case import_constants.GL.LINEAR_MIPMAP_NEAREST:
+      case 9985 /* LINEAR_MIPMAP_NEAREST */:
         return { minFilter: "linear", mipmapFilter: "nearest" };
-      case import_constants.GL.NEAREST_MIPMAP_LINEAR:
+      case 9986 /* NEAREST_MIPMAP_LINEAR */:
         return { minFilter: "nearest", mipmapFilter: "linear" };
-      case import_constants.GL.LINEAR_MIPMAP_LINEAR:
+      case 9987 /* LINEAR_MIPMAP_LINEAR */:
         return { minFilter: "linear", mipmapFilter: "linear" };
       default:
         return {};
@@ -764,7 +764,8 @@ var __exports__ = (() => {
     if (imageBasedLightingEnvironment) {
       parsedMaterial.bindings.pbr_diffuseEnvSampler = imageBasedLightingEnvironment.diffuseEnvSampler.texture;
       parsedMaterial.bindings.pbr_specularEnvSampler = imageBasedLightingEnvironment.specularEnvSampler.texture;
-      parsedMaterial.bindings.pbr_BrdfLUT = imageBasedLightingEnvironment.brdfLutTexture.texture;
+      parsedMaterial.bindings.pbr_brdfLUT = imageBasedLightingEnvironment.brdfLutTexture.texture;
+      parsedMaterial.uniforms.IBLenabled = true;
       parsedMaterial.uniforms.scaleIBLAmbient = [1, 1];
     }
     if (options?.pbrDebug) {
@@ -787,81 +788,181 @@ var __exports__ = (() => {
     if (options?.lights)
       parsedMaterial.defines["USE_LIGHTS"] = true;
     if (material) {
-      parseMaterial(device, material, parsedMaterial);
+      if (options.validateAttributes !== false) {
+        warnOnMissingExpectedAttributes(material, attributes);
+      }
+      parseMaterial(device, material, parsedMaterial, options.gltf);
     }
     return parsedMaterial;
   }
-  function parseMaterial(device, material, parsedMaterial) {
-    parsedMaterial.uniforms.unlit = Boolean(material.unlit);
+  function warnOnMissingExpectedAttributes(material, attributes) {
+    const uvDependentTextureSlots = getUvDependentTextureSlots(material);
+    if (uvDependentTextureSlots.length > 0 && !attributes["TEXCOORD_0"]) {
+      import_core.log.warn(
+        `glTF material uses ${uvDependentTextureSlots.join(", ")} but primitive is missing TEXCOORD_0; textured shading will sample the default UV coordinates`
+      )();
+    }
+    const isUnlitMaterial = Boolean(material.unlit || material.extensions?.KHR_materials_unlit);
+    if (isUnlitMaterial || attributes["NORMAL"]) {
+      return;
+    }
+    const missingNormalReason = material.normalTexture ? "lit PBR shading with normalTexture" : "lit PBR shading";
+    import_core.log.warn(
+      `glTF primitive is missing NORMAL while using ${missingNormalReason}; shading will fall back to geometric normals`
+    )();
+  }
+  function getUvDependentTextureSlots(material) {
+    const uvDependentTextureSlots = [];
+    if (material.pbrMetallicRoughness?.baseColorTexture) {
+      uvDependentTextureSlots.push("baseColorTexture");
+    }
+    if (material.pbrMetallicRoughness?.metallicRoughnessTexture) {
+      uvDependentTextureSlots.push("metallicRoughnessTexture");
+    }
+    if (material.normalTexture) {
+      uvDependentTextureSlots.push("normalTexture");
+    }
+    if (material.occlusionTexture) {
+      uvDependentTextureSlots.push("occlusionTexture");
+    }
+    if (material.emissiveTexture) {
+      uvDependentTextureSlots.push("emissiveTexture");
+    }
+    if (material.extensions?.KHR_materials_specular?.specularTexture) {
+      uvDependentTextureSlots.push("KHR_materials_specular.specularTexture");
+    }
+    if (material.extensions?.KHR_materials_specular?.specularColorTexture) {
+      uvDependentTextureSlots.push("KHR_materials_specular.specularColorTexture");
+    }
+    if (material.extensions?.KHR_materials_transmission?.transmissionTexture) {
+      uvDependentTextureSlots.push("KHR_materials_transmission.transmissionTexture");
+    }
+    if (material.extensions?.KHR_materials_clearcoat?.clearcoatTexture) {
+      uvDependentTextureSlots.push("KHR_materials_clearcoat.clearcoatTexture");
+    }
+    if (material.extensions?.KHR_materials_clearcoat?.clearcoatRoughnessTexture) {
+      uvDependentTextureSlots.push("KHR_materials_clearcoat.clearcoatRoughnessTexture");
+    }
+    if (material.extensions?.KHR_materials_sheen?.sheenColorTexture) {
+      uvDependentTextureSlots.push("KHR_materials_sheen.sheenColorTexture");
+    }
+    if (material.extensions?.KHR_materials_sheen?.sheenRoughnessTexture) {
+      uvDependentTextureSlots.push("KHR_materials_sheen.sheenRoughnessTexture");
+    }
+    if (material.extensions?.KHR_materials_iridescence?.iridescenceTexture) {
+      uvDependentTextureSlots.push("KHR_materials_iridescence.iridescenceTexture");
+    }
+    if (material.extensions?.KHR_materials_anisotropy?.anisotropyTexture) {
+      uvDependentTextureSlots.push("KHR_materials_anisotropy.anisotropyTexture");
+    }
+    return uvDependentTextureSlots;
+  }
+  function parseMaterial(device, material, parsedMaterial, gltf) {
+    parsedMaterial.uniforms.unlit = Boolean(
+      material.unlit || material.extensions?.KHR_materials_unlit
+    );
     if (material.pbrMetallicRoughness) {
-      parsePbrMetallicRoughness(device, material.pbrMetallicRoughness, parsedMaterial);
+      parsePbrMetallicRoughness(device, material.pbrMetallicRoughness, parsedMaterial, gltf);
     }
     if (material.normalTexture) {
-      addTexture(
-        device,
-        material.normalTexture,
-        "pbr_normalSampler",
-        "HAS_NORMALMAP",
-        parsedMaterial
-      );
+      addTexture(device, material.normalTexture, "pbr_normalSampler", parsedMaterial, {
+        featureOptions: {
+          define: "HAS_NORMALMAP",
+          enabledUniformName: "normalMapEnabled"
+        },
+        gltf
+      });
       const { scale: scale4 = 1 } = material.normalTexture;
       parsedMaterial.uniforms.normalScale = scale4;
     }
     if (material.occlusionTexture) {
-      addTexture(
-        device,
-        material.occlusionTexture,
-        "pbr_occlusionSampler",
-        "HAS_OCCLUSIONMAP",
-        parsedMaterial
-      );
+      addTexture(device, material.occlusionTexture, "pbr_occlusionSampler", parsedMaterial, {
+        featureOptions: {
+          define: "HAS_OCCLUSIONMAP",
+          enabledUniformName: "occlusionMapEnabled"
+        },
+        gltf
+      });
       const { strength = 1 } = material.occlusionTexture;
       parsedMaterial.uniforms.occlusionStrength = strength;
     }
+    parsedMaterial.uniforms.emissiveFactor = material.emissiveFactor || [0, 0, 0];
     if (material.emissiveTexture) {
-      addTexture(
-        device,
-        material.emissiveTexture,
-        "pbr_emissiveSampler",
-        "HAS_EMISSIVEMAP",
-        parsedMaterial
-      );
-      parsedMaterial.uniforms.emissiveFactor = material.emissiveFactor || [0, 0, 0];
+      addTexture(device, material.emissiveTexture, "pbr_emissiveSampler", parsedMaterial, {
+        featureOptions: {
+          define: "HAS_EMISSIVEMAP",
+          enabledUniformName: "emissiveMapEnabled"
+        },
+        gltf
+      });
     }
-    switch (material.alphaMode || "MASK") {
-      case "MASK":
+    parseMaterialExtensions(device, material.extensions, parsedMaterial, gltf);
+    switch (material.alphaMode || "OPAQUE") {
+      case "OPAQUE":
+        break;
+      case "MASK": {
         const { alphaCutoff = 0.5 } = material;
         parsedMaterial.defines["ALPHA_CUTOFF"] = true;
+        parsedMaterial.uniforms.alphaCutoffEnabled = true;
         parsedMaterial.uniforms.alphaCutoff = alphaCutoff;
         break;
+      }
       case "BLEND":
         import_core.log.warn("glTF BLEND alphaMode might not work well because it requires mesh sorting")();
-        parsedMaterial.parameters.blend = true;
-        parsedMaterial.parameters.blendColorOperation = "add";
-        parsedMaterial.parameters.blendColorSrcFactor = "src-alpha";
-        parsedMaterial.parameters.blendColorDstFactor = "one-minus-src-alpha";
-        parsedMaterial.parameters.blendAlphaOperation = "add";
-        parsedMaterial.parameters.blendAlphaSrcFactor = "one";
-        parsedMaterial.parameters.blendAlphaDstFactor = "one-minus-src-alpha";
-        parsedMaterial.glParameters["blend"] = true;
-        parsedMaterial.glParameters["blendEquation"] = import_constants2.GL.FUNC_ADD;
-        parsedMaterial.glParameters["blendFunc"] = [
-          import_constants2.GL.SRC_ALPHA,
-          import_constants2.GL.ONE_MINUS_SRC_ALPHA,
-          import_constants2.GL.ONE,
-          import_constants2.GL.ONE_MINUS_SRC_ALPHA
-        ];
+        applyAlphaBlendParameters(parsedMaterial);
         break;
     }
   }
-  function parsePbrMetallicRoughness(device, pbrMetallicRoughness, parsedMaterial) {
+  function applyAlphaBlendParameters(parsedMaterial) {
+    parsedMaterial.parameters.blend = true;
+    parsedMaterial.parameters.blendColorOperation = "add";
+    parsedMaterial.parameters.blendColorSrcFactor = "src-alpha";
+    parsedMaterial.parameters.blendColorDstFactor = "one-minus-src-alpha";
+    parsedMaterial.parameters.blendAlphaOperation = "add";
+    parsedMaterial.parameters.blendAlphaSrcFactor = "one";
+    parsedMaterial.parameters.blendAlphaDstFactor = "one-minus-src-alpha";
+    parsedMaterial.glParameters["blend"] = true;
+    parsedMaterial.glParameters["blendEquation"] = 32774 /* FUNC_ADD */;
+    parsedMaterial.glParameters["blendFunc"] = [
+      770 /* SRC_ALPHA */,
+      771 /* ONE_MINUS_SRC_ALPHA */,
+      1 /* ONE */,
+      771 /* ONE_MINUS_SRC_ALPHA */
+    ];
+  }
+  function applyTransmissionBlendApproximation(parsedMaterial) {
+    parsedMaterial.parameters.blend = true;
+    parsedMaterial.parameters.depthWriteEnabled = false;
+    parsedMaterial.parameters.blendColorOperation = "add";
+    parsedMaterial.parameters.blendColorSrcFactor = "one";
+    parsedMaterial.parameters.blendColorDstFactor = "one-minus-src-alpha";
+    parsedMaterial.parameters.blendAlphaOperation = "add";
+    parsedMaterial.parameters.blendAlphaSrcFactor = "one";
+    parsedMaterial.parameters.blendAlphaDstFactor = "one-minus-src-alpha";
+    parsedMaterial.glParameters["blend"] = true;
+    parsedMaterial.glParameters["depthMask"] = false;
+    parsedMaterial.glParameters["blendEquation"] = 32774 /* FUNC_ADD */;
+    parsedMaterial.glParameters["blendFunc"] = [
+      1 /* ONE */,
+      771 /* ONE_MINUS_SRC_ALPHA */,
+      1 /* ONE */,
+      771 /* ONE_MINUS_SRC_ALPHA */
+    ];
+  }
+  function parsePbrMetallicRoughness(device, pbrMetallicRoughness, parsedMaterial, gltf) {
     if (pbrMetallicRoughness.baseColorTexture) {
       addTexture(
         device,
         pbrMetallicRoughness.baseColorTexture,
         "pbr_baseColorSampler",
-        "HAS_BASECOLORMAP",
-        parsedMaterial
+        parsedMaterial,
+        {
+          featureOptions: {
+            define: "HAS_BASECOLORMAP",
+            enabledUniformName: "baseColorMapEnabled"
+          },
+          gltf
+        }
       );
     }
     parsedMaterial.uniforms.baseColorFactor = pbrMetallicRoughness.baseColorFactor || [1, 1, 1, 1];
@@ -870,15 +971,278 @@ var __exports__ = (() => {
         device,
         pbrMetallicRoughness.metallicRoughnessTexture,
         "pbr_metallicRoughnessSampler",
-        "HAS_METALROUGHNESSMAP",
-        parsedMaterial
+        parsedMaterial,
+        {
+          featureOptions: {
+            define: "HAS_METALROUGHNESSMAP",
+            enabledUniformName: "metallicRoughnessMapEnabled"
+          },
+          gltf
+        }
       );
     }
     const { metallicFactor = 1, roughnessFactor = 1 } = pbrMetallicRoughness;
     parsedMaterial.uniforms.metallicRoughnessValues = [metallicFactor, roughnessFactor];
   }
-  function addTexture(device, gltfTexture, uniformName, define, parsedMaterial) {
-    const image = gltfTexture.texture.source.image;
+  function parseMaterialExtensions(device, extensions, parsedMaterial, gltf) {
+    if (!extensions) {
+      return;
+    }
+    if (hasMaterialExtensionShading(extensions)) {
+      parsedMaterial.defines["USE_MATERIAL_EXTENSIONS"] = true;
+    }
+    parseSpecularExtension(device, extensions.KHR_materials_specular, parsedMaterial, gltf);
+    parseIorExtension(extensions.KHR_materials_ior, parsedMaterial);
+    parseTransmissionExtension(device, extensions.KHR_materials_transmission, parsedMaterial, gltf);
+    parseVolumeExtension(device, extensions.KHR_materials_volume, parsedMaterial, gltf);
+    parseClearcoatExtension(device, extensions.KHR_materials_clearcoat, parsedMaterial, gltf);
+    parseSheenExtension(device, extensions.KHR_materials_sheen, parsedMaterial, gltf);
+    parseIridescenceExtension(device, extensions.KHR_materials_iridescence, parsedMaterial, gltf);
+    parseAnisotropyExtension(device, extensions.KHR_materials_anisotropy, parsedMaterial, gltf);
+    parseEmissiveStrengthExtension(extensions.KHR_materials_emissive_strength, parsedMaterial);
+  }
+  function hasMaterialExtensionShading(extensions) {
+    return Boolean(
+      extensions.KHR_materials_specular || extensions.KHR_materials_ior || extensions.KHR_materials_transmission || extensions.KHR_materials_volume || extensions.KHR_materials_clearcoat || extensions.KHR_materials_sheen || extensions.KHR_materials_iridescence || extensions.KHR_materials_anisotropy
+    );
+  }
+  function parseSpecularExtension(device, extension, parsedMaterial, gltf) {
+    if (!extension) {
+      return;
+    }
+    if (extension.specularColorFactor) {
+      parsedMaterial.uniforms.specularColorFactor = extension.specularColorFactor;
+    }
+    if (extension.specularFactor !== void 0) {
+      parsedMaterial.uniforms.specularIntensityFactor = extension.specularFactor;
+    }
+    if (extension.specularColorTexture) {
+      addTexture(device, extension.specularColorTexture, "pbr_specularColorSampler", parsedMaterial, {
+        featureOptions: {
+          define: "HAS_SPECULARCOLORMAP",
+          enabledUniformName: "specularColorMapEnabled"
+        },
+        gltf
+      });
+    }
+    if (extension.specularTexture) {
+      addTexture(device, extension.specularTexture, "pbr_specularIntensitySampler", parsedMaterial, {
+        featureOptions: {
+          define: "HAS_SPECULARINTENSITYMAP",
+          enabledUniformName: "specularIntensityMapEnabled"
+        },
+        gltf
+      });
+    }
+  }
+  function parseIorExtension(extension, parsedMaterial) {
+    if (extension?.ior !== void 0) {
+      parsedMaterial.uniforms.ior = extension.ior;
+    }
+  }
+  function parseTransmissionExtension(device, extension, parsedMaterial, gltf) {
+    if (!extension) {
+      return;
+    }
+    if (extension.transmissionFactor !== void 0) {
+      parsedMaterial.uniforms.transmissionFactor = extension.transmissionFactor;
+    }
+    if (extension.transmissionTexture) {
+      addTexture(device, extension.transmissionTexture, "pbr_transmissionSampler", parsedMaterial, {
+        featureOptions: {
+          define: "HAS_TRANSMISSIONMAP",
+          enabledUniformName: "transmissionMapEnabled"
+        },
+        gltf
+      });
+    }
+    if ((extension.transmissionFactor ?? 0) > 0 || extension.transmissionTexture) {
+      import_core.log.warn(
+        "KHR_materials_transmission uses a premultiplied-alpha blending approximation and may require mesh sorting"
+      )();
+      applyTransmissionBlendApproximation(parsedMaterial);
+    }
+  }
+  function parseVolumeExtension(device, extension, parsedMaterial, gltf) {
+    if (!extension) {
+      return;
+    }
+    if (extension.thicknessFactor !== void 0) {
+      parsedMaterial.uniforms.thicknessFactor = extension.thicknessFactor;
+    }
+    if (extension.thicknessTexture) {
+      addTexture(device, extension.thicknessTexture, "pbr_thicknessSampler", parsedMaterial, {
+        featureOptions: {
+          define: "HAS_THICKNESSMAP"
+        },
+        gltf
+      });
+    }
+    if (extension.attenuationDistance !== void 0) {
+      parsedMaterial.uniforms.attenuationDistance = extension.attenuationDistance;
+    }
+    if (extension.attenuationColor) {
+      parsedMaterial.uniforms.attenuationColor = extension.attenuationColor;
+    }
+  }
+  function parseClearcoatExtension(device, extension, parsedMaterial, gltf) {
+    if (!extension) {
+      return;
+    }
+    if (extension.clearcoatFactor !== void 0) {
+      parsedMaterial.uniforms.clearcoatFactor = extension.clearcoatFactor;
+    }
+    if (extension.clearcoatRoughnessFactor !== void 0) {
+      parsedMaterial.uniforms.clearcoatRoughnessFactor = extension.clearcoatRoughnessFactor;
+    }
+    if (extension.clearcoatTexture) {
+      addTexture(device, extension.clearcoatTexture, "pbr_clearcoatSampler", parsedMaterial, {
+        featureOptions: {
+          define: "HAS_CLEARCOATMAP",
+          enabledUniformName: "clearcoatMapEnabled"
+        },
+        gltf
+      });
+    }
+    if (extension.clearcoatRoughnessTexture) {
+      addTexture(
+        device,
+        extension.clearcoatRoughnessTexture,
+        "pbr_clearcoatRoughnessSampler",
+        parsedMaterial,
+        {
+          featureOptions: {
+            define: "HAS_CLEARCOATROUGHNESSMAP",
+            enabledUniformName: "clearcoatRoughnessMapEnabled"
+          },
+          gltf
+        }
+      );
+    }
+    if (extension.clearcoatNormalTexture) {
+      addTexture(
+        device,
+        extension.clearcoatNormalTexture,
+        "pbr_clearcoatNormalSampler",
+        parsedMaterial,
+        {
+          featureOptions: {
+            define: "HAS_CLEARCOATNORMALMAP"
+          },
+          gltf
+        }
+      );
+    }
+  }
+  function parseSheenExtension(device, extension, parsedMaterial, gltf) {
+    if (!extension) {
+      return;
+    }
+    if (extension.sheenColorFactor) {
+      parsedMaterial.uniforms.sheenColorFactor = extension.sheenColorFactor;
+    }
+    if (extension.sheenRoughnessFactor !== void 0) {
+      parsedMaterial.uniforms.sheenRoughnessFactor = extension.sheenRoughnessFactor;
+    }
+    if (extension.sheenColorTexture) {
+      addTexture(device, extension.sheenColorTexture, "pbr_sheenColorSampler", parsedMaterial, {
+        featureOptions: {
+          define: "HAS_SHEENCOLORMAP",
+          enabledUniformName: "sheenColorMapEnabled"
+        },
+        gltf
+      });
+    }
+    if (extension.sheenRoughnessTexture) {
+      addTexture(
+        device,
+        extension.sheenRoughnessTexture,
+        "pbr_sheenRoughnessSampler",
+        parsedMaterial,
+        {
+          featureOptions: {
+            define: "HAS_SHEENROUGHNESSMAP",
+            enabledUniformName: "sheenRoughnessMapEnabled"
+          },
+          gltf
+        }
+      );
+    }
+  }
+  function parseIridescenceExtension(device, extension, parsedMaterial, gltf) {
+    if (!extension) {
+      return;
+    }
+    if (extension.iridescenceFactor !== void 0) {
+      parsedMaterial.uniforms.iridescenceFactor = extension.iridescenceFactor;
+    }
+    if (extension.iridescenceIor !== void 0) {
+      parsedMaterial.uniforms.iridescenceIor = extension.iridescenceIor;
+    }
+    if (extension.iridescenceThicknessMinimum !== void 0 || extension.iridescenceThicknessMaximum !== void 0) {
+      parsedMaterial.uniforms.iridescenceThicknessRange = [
+        extension.iridescenceThicknessMinimum ?? 100,
+        extension.iridescenceThicknessMaximum ?? 400
+      ];
+    }
+    if (extension.iridescenceTexture) {
+      addTexture(device, extension.iridescenceTexture, "pbr_iridescenceSampler", parsedMaterial, {
+        featureOptions: {
+          define: "HAS_IRIDESCENCEMAP",
+          enabledUniformName: "iridescenceMapEnabled"
+        },
+        gltf
+      });
+    }
+    if (extension.iridescenceThicknessTexture) {
+      addTexture(
+        device,
+        extension.iridescenceThicknessTexture,
+        "pbr_iridescenceThicknessSampler",
+        parsedMaterial,
+        {
+          featureOptions: {
+            define: "HAS_IRIDESCENCETHICKNESSMAP"
+          },
+          gltf
+        }
+      );
+    }
+  }
+  function parseAnisotropyExtension(device, extension, parsedMaterial, gltf) {
+    if (!extension) {
+      return;
+    }
+    if (extension.anisotropyStrength !== void 0) {
+      parsedMaterial.uniforms.anisotropyStrength = extension.anisotropyStrength;
+    }
+    if (extension.anisotropyRotation !== void 0) {
+      parsedMaterial.uniforms.anisotropyRotation = extension.anisotropyRotation;
+    }
+    if (extension.anisotropyTexture) {
+      addTexture(device, extension.anisotropyTexture, "pbr_anisotropySampler", parsedMaterial, {
+        featureOptions: {
+          define: "HAS_ANISOTROPYMAP",
+          enabledUniformName: "anisotropyMapEnabled"
+        },
+        gltf
+      });
+    }
+  }
+  function parseEmissiveStrengthExtension(extension, parsedMaterial) {
+    if (extension?.emissiveStrength !== void 0) {
+      parsedMaterial.uniforms.emissiveStrength = extension.emissiveStrength;
+    }
+  }
+  function addTexture(device, gltfTexture, uniformName, parsedMaterial, textureParseOptions = {}) {
+    const { featureOptions = {}, gltf } = textureParseOptions;
+    const { define, enabledUniformName } = featureOptions;
+    const resolvedTextureInfo = resolveTextureInfo(gltfTexture, gltf);
+    const image = resolvedTextureInfo.texture?.source?.image;
+    if (!image) {
+      import_core.log.warn(`Skipping unresolved glTF texture for ${String(uniformName)}`)();
+      return;
+    }
     const gltfSampler = {
       wrapS: 10497,
       // default REPEAT S (U) wrapping mode.
@@ -888,10 +1252,10 @@ var __exports__ = (() => {
       // default LINEAR filtering
       magFilter: 9729,
       // default LINEAR filtering
-      ...gltfTexture?.texture?.sampler
+      ...resolvedTextureInfo?.texture?.sampler
     };
     const baseOptions = {
-      id: gltfTexture.uniformName || gltfTexture.id,
+      id: resolvedTextureInfo.uniformName || resolvedTextureInfo.id,
       sampler: convertSampler(gltfSampler)
     };
     let texture;
@@ -909,8 +1273,34 @@ var __exports__ = (() => {
     parsedMaterial.bindings[uniformName] = texture;
     if (define)
       parsedMaterial.defines[define] = true;
+    if (enabledUniformName) {
+      parsedMaterial.uniforms[enabledUniformName] = true;
+    }
     parsedMaterial.generatedTextures.push(texture);
   }
+  function resolveTextureInfo(gltfTexture, gltf) {
+    if (gltfTexture.texture || gltfTexture.index === void 0 || !gltf?.textures) {
+      return gltfTexture;
+    }
+    const resolvedTextureEntry = gltf.textures[gltfTexture.index];
+    if (!resolvedTextureEntry) {
+      return gltfTexture;
+    }
+    if ("texture" in resolvedTextureEntry && resolvedTextureEntry.texture) {
+      return {
+        ...resolvedTextureEntry,
+        ...gltfTexture,
+        texture: resolvedTextureEntry.texture
+      };
+    }
+    if (!("source" in resolvedTextureEntry)) {
+      return gltfTexture;
+    }
+    return {
+      ...gltfTexture,
+      texture: resolvedTextureEntry
+    };
+  }
   function createCompressedTextureFallback(device, baseOptions) {
     return device.createTexture({
       ...baseOptions,
@@ -3579,6 +3969,7 @@ var __exports__ = (() => {
   };
 
   // src/parsers/parse-gltf-lights.ts
+  var GLTF_COLOR_FACTOR = 255;
   function parseGLTFLights(gltf) {
     const lightDefs = (
       // `postProcessGLTF()` moves KHR_lights_punctual into `gltf.lights`.
@@ -3588,6 +3979,8 @@ var __exports__ = (() => {
       return [];
     }
     const lights = [];
+    const parentNodeById = createParentNodeMap(gltf.nodes || []);
+    const worldMatrixByNodeId = /* @__PURE__ */ new Map();
     for (const node of gltf.nodes || []) {
       const lightIndex = node.light ?? node.extensions?.KHR_lights_punctual?.light;
       if (typeof lightIndex !== "number") {
@@ -3597,18 +3990,21 @@ var __exports__ = (() => {
       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;
@@ -3616,8 +4012,11 @@ var __exports__ = (() => {
     }
     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)];
@@ -3630,8 +4029,8 @@ var __exports__ = (() => {
       attenuation
     };
   }
-  function parseDirectionalLight(node, color, intensity) {
-    const direction = getNodeDirection(node);
+  function parseDirectionalLight(worldMatrix, color, intensity) {
+    const direction = getLightDirection(worldMatrix);
     return {
       type: "directional",
       direction,
@@ -3639,27 +4038,72 @@ var __exports__ = (() => {
       intensity
     };
   }
-  function getNodePosition(node) {
-    if (node.matrix) {
-      return new 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 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 Matrix4(node.matrix).transformDirection([0, 0, -1]);
+      return new Matrix4(node.matrix);
+    }
+    const matrix = new Matrix4();
+    if (node.translation) {
+      matrix.translate(node.translation);
     }
     if (node.rotation) {
-      return new Matrix4().fromQuaternion(node.rotation).transformDirection([0, 0, -1]);
+      matrix.multiplyRight(new 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]);
   }
 
   // src/parsers/parse-gltf.ts
-  var import_engine3 = __toESM(require_engine(), 1);
+  var import_engine4 = __toESM(require_engine(), 1);
+  var import_shadertools2 = __toESM(require_shadertools(), 1);
 
   // src/webgl-to-webgpu/convert-webgl-topology.ts
   function convertGLDrawModeToTopology(drawMode) {
@@ -3681,8 +4125,9 @@ var __exports__ = (() => {
 
   // src/gltf/create-gltf-model.ts
   var import_core3 = __toESM(require_core(), 1);
-  var import_shadertools = __toESM(require_shadertools(), 1);
   var import_engine2 = __toESM(require_engine(), 1);
+  var import_shadertools = __toESM(require_shadertools(), 1);
+  var import_engine3 = __toESM(require_engine(), 1);
   var SHADER = (
     /* WGSL */
     `
@@ -3838,6 +4283,25 @@ fn fragmentMain(inputs: FragmentInputs) -> @location(0) vec4f {
   }
 `
   );
+  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)();
@@ -3861,15 +4325,52 @@ fn fragmentMain(inputs: FragmentInputs) -> @location(0) vec4f {
       defines: { ...parsedPPBRMaterial.defines, ...modelOptions.defines },
       parameters: { ...parameters, ...parsedPPBRMaterial.parameters, ...modelOptions.parameters }
     };
-    const model = new import_engine2.Model(device, modelProps);
-    const { camera, ...pbrMaterialProps } = {
+    const material = options.material || createGLTFMaterial(device, {
+      id: id ? `${id}-material` : void 0,
+      parsedPPBRMaterial
+    });
+    modelProps.material = material;
+    const model = new import_engine3.Model(device, modelProps);
+    const sceneShaderInputValues = {
       ...parsedPPBRMaterial.uniforms,
       ...modelOptions.uniforms,
       ...parsedPPBRMaterial.bindings,
       ...modelOptions.bindings
     };
-    model.shaderInputs.setProps({ pbrMaterial: pbrMaterialProps, pbrProjection: { camera } });
-    return new import_engine2.ModelNode({ managedResources, model });
+    const sceneShaderInputProps = getSceneShaderInputProps(
+      model.shaderInputs.getModules(),
+      material,
+      sceneShaderInputValues
+    );
+    model.shaderInputs.setProps(sceneShaderInputProps);
+    return new import_engine3.ModelNode({ managedResources, model });
+  }
+  function isMaterialBindingResource(value) {
+    return value instanceof import_core3.Buffer || value instanceof import_engine2.DynamicTexture || value instanceof import_core3.Sampler || value instanceof import_core3.Texture || value instanceof import_core3.TextureView;
+  }
+  function getSceneShaderInputProps(modules, material, shaderInputValues) {
+    const propertyToModuleNameMap = /* @__PURE__ */ new Map();
+    for (const module of modules) {
+      for (const uniformName of Object.keys(module.uniformTypes || {})) {
+        propertyToModuleNameMap.set(uniformName, module.name);
+      }
+      for (const binding of module.bindingLayout || []) {
+        propertyToModuleNameMap.set(binding.name, module.name);
+      }
+    }
+    const sceneShaderInputProps = {};
+    for (const [propertyName, value] of Object.entries(shaderInputValues)) {
+      if (value === void 0) {
+        continue;
+      }
+      const moduleName = propertyToModuleNameMap.get(propertyName);
+      if (!moduleName || material.ownsModule(moduleName)) {
+        continue;
+      }
+      sceneShaderInputProps[moduleName] ||= {};
+      sceneShaderInputProps[moduleName][propertyName] = value;
+    }
+    return sceneShaderInputProps;
   }
 
   // src/parsers/parse-gltf.ts
@@ -3882,9 +4383,36 @@ fn fragmentMain(inputs: FragmentInputs) -> @location(0) vec4f {
   };
   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();
@@ -3918,15 +4446,15 @@ fn fragmentMain(inputs: FragmentInputs) -> @location(0) vec4f {
           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,
@@ -3935,31 +4463,46 @@ fn fragmentMain(inputs: FragmentInputs) -> @location(0) vec4f {
       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)
+      (gltfPrimitive, i) => createNodeForGLTFPrimitive({
+        device,
+        gltfPrimitive,
+        primitiveIndex: i,
+        gltfMesh,
+        gltf,
+        gltfMaterialIdToMaterialMap,
+        options
+      })
     );
-    const mesh = new import_engine3.GroupNode({
+    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
@@ -3976,13 +4519,16 @@ fn fragmentMain(inputs: FragmentInputs) -> @location(0) vec4f {
       const { components, size, value } = attribute;
       attributes[attributeName] = { size: size ?? components, value };
     }
-    return new import_engine3.Geometry({
+    return new import_engine4.Geometry({
       id,
       topology,
       indices: gltfPrimitive.indices.value,
       attributes
     });
   }
+  function getGLTFMaterialId(gltfMaterial, materialIndex) {
+    return gltfMaterial.name || gltfMaterial.id || `material-${materialIndex}`;
+  }
 
   // src/gltf/gltf-animator.ts
   var import_core6 = __toESM(require_core(), 1);
@@ -4129,6 +4675,9 @@ fn fragmentMain(inputs: FragmentInputs) -> @location(0) vec4f {
     }
   };
 
+  // src/parsers/parse-gltf-animations.ts
+  var import_core7 = __toESM(require_core(), 1);
+
   // src/webgl-to-webgpu/convert-webgl-attribute.ts
   var ATTRIBUTE_TYPE_TO_COMPONENTS = {
     SCALAR: 1,
@@ -4161,29 +4710,48 @@ fn fragmentMain(inputs: FragmentInputs) -> @location(0) vec4f {
     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);
@@ -4199,7 +4767,7 @@ fn fragmentMain(inputs: FragmentInputs) -> @location(0) vec4f {
       return accessorCache.get(accessor);
     }
     const { typedArray: array, components } = accessorToTypedArray(accessor);
-    assert3(components > 1, "accessorToJsArray2D must have more than 1 component");
+    assert3(components >= 1, "accessorToJsArray2D must have at least 1 component");
     const result = [];
     for (let i = 0; i < array.length; i += components) {
       result.push(Array.from(array.slice(i, i + components)));
@@ -4213,26 +4781,259 @@ fn fragmentMain(inputs: FragmentInputs) -> @location(0) vec4f {
     }
   }
 
+  // src/gltf/gltf-extension-support.ts
+  var UNKNOWN_EXTENSION_SUPPORT = {
+    supportLevel: "none",
+    comment: "Not currently listed in the luma.gl glTF extension support registry."
+  };
+  var GLTF_EXTENSION_SUPPORT_REGISTRY = {
+    KHR_draco_mesh_compression: {
+      supportLevel: "built-in",
+      comment: "Decoded by loaders.gl before luma.gl builds the scenegraph."
+    },
+    EXT_meshopt_compression: {
+      supportLevel: "built-in",
+      comment: "Meshopt-compressed primitives are decoded during load."
+    },
+    KHR_mesh_quantization: {
+      supportLevel: "built-in",
+      comment: "Quantized accessors are unpacked before geometry creation."
+    },
+    KHR_lights_punctual: {
+      supportLevel: "built-in",
+      comment: "Parsed into luma.gl Light objects."
+    },
+    KHR_materials_unlit: {
+      supportLevel: "built-in",
+      comment: "Unlit materials bypass the default lighting path."
+    },
+    KHR_materials_emissive_strength: {
+      supportLevel: "built-in",
+      comment: "Applied by the stock PBR shader."
+    },
+    KHR_texture_basisu: {
+      supportLevel: "built-in",
+      comment: "BasisU / KTX2 textures pass through when the device supports them."
+    },
+    KHR_texture_transform: {
+      supportLevel: "built-in",
+      comment: "UV transforms are applied during load."
+    },
+    EXT_texture_webp: {
+      supportLevel: "loader-only",
+      comment: "Texture source is resolved during load; final support depends on browser and device decode support."
+    },
+    EXT_texture_avif: {
+      supportLevel: "loader-only",
+      comment: "Texture source is resolved during load; final support depends on browser and device decode support."
+    },
+    KHR_materials_specular: {
+      supportLevel: "built-in",
+      comment: "The stock shader now applies specular factors and textures to the dielectric F0 term."
+    },
+    KHR_materials_ior: {
+      supportLevel: "built-in",
+      comment: "The stock shader now drives dielectric reflectance from the glTF IOR value."
+    },
+    KHR_materials_transmission: {
+      supportLevel: "built-in",
+      comment: "The stock shader now applies transmission to the base layer and exposes transparency through alpha, without a scene-color refraction buffer."
+    },
+    KHR_materials_volume: {
+      supportLevel: "built-in",
+      comment: "Thickness and attenuation now tint transmitted light in the stock shader."
+    },
+    KHR_materials_clearcoat: {
+      supportLevel: "built-in",
+      comment: "The stock shader now adds a secondary clearcoat specular lobe."
+    },
+    KHR_materials_sheen: {
+      supportLevel: "built-in",
+      comment: "The stock shader now adds a sheen lobe for cloth-like materials."
+    },
+    KHR_materials_iridescence: {
+      supportLevel: "built-in",
+      comment: "The stock shader now tints specular response with a view-dependent thin-film iridescence approximation."
+    },
+    KHR_materials_anisotropy: {
+      supportLevel: "built-in",
+      comment: "The stock shader now shapes highlights and IBL response with an anisotropy-direction approximation."
+    },
+    KHR_materials_pbrSpecularGlossiness: {
+      supportLevel: "loader-only",
+      comment: "Extension data can be loaded, but it is not translated into the default metallic-roughness material path."
+    },
+    KHR_materials_variants: {
+      supportLevel: "loader-only",
+      comment: "Variant metadata can be loaded, but applications must choose and apply variants."
+    },
+    EXT_mesh_gpu_instancing: {
+      supportLevel: "none",
+      comment: "GPU instancing data is not yet converted into luma.gl instanced draw setup."
+    },
+    KHR_node_visibility: {
+      supportLevel: "none",
+      comment: "Node-visibility animations and toggles are not mapped onto runtime scenegraph state."
+    },
+    KHR_animation_pointer: {
+      supportLevel: "none",
+      comment: "Animation pointers are not mapped onto runtime scenegraph updates."
+    },
+    KHR_materials_diffuse_transmission: {
+      supportLevel: "none",
+      comment: "Diffuse-transmission shading is not implemented in the stock PBR shader."
+    },
+    KHR_materials_dispersion: {
+      supportLevel: "none",
+      comment: "Chromatic dispersion is not implemented in the stock PBR shader."
+    },
+    KHR_materials_volume_scatter: {
+      supportLevel: "none",
+      comment: "Volume scattering is not implemented in the stock PBR shader."
+    },
+    KHR_xmp: {
+      supportLevel: "none",
+      comment: "Metadata payloads remain in the loaded glTF, but luma.gl does not interpret them."
+    },
+    KHR_xmp_json_ld: {
+      supportLevel: "none",
+      comment: "Metadata is preserved in the glTF, but luma.gl does not interpret it."
+    },
+    EXT_lights_image_based: {
+      supportLevel: "none",
+      comment: "Use loadPBREnvironment() or custom environment setup instead."
+    },
+    EXT_texture_video: {
+      supportLevel: "none",
+      comment: "Video textures are not created automatically by the stock pipeline."
+    },
+    MSFT_lod: {
+      supportLevel: "none",
+      comment: "Level-of-detail switching is not implemented in the stock scenegraph loader."
+    }
+  };
+  function getGLTFExtensionSupport(gltf) {
+    const extensionNames = Array.from(collectGLTFExtensionNames(gltf)).sort();
+    const extensionSupportEntries = extensionNames.map(
+      (extensionName) => {
+        const extensionSupportDefinition = GLTF_EXTENSION_SUPPORT_REGISTRY[extensionName] || UNKNOWN_EXTENSION_SUPPORT;
+        return [
+          extensionName,
+          {
+            extensionName,
+            supported: extensionSupportDefinition.supportLevel === "built-in",
+            supportLevel: extensionSupportDefinition.supportLevel,
+            comment: extensionSupportDefinition.comment
+          }
+        ];
+      }
+    );
+    return new Map(extensionSupportEntries);
+  }
+  function collectGLTFExtensionNames(gltf) {
+    const gltfWithRemovedExtensions = gltf;
+    const extensionNames = /* @__PURE__ */ new Set();
+    addExtensionNames(extensionNames, gltf.extensionsUsed);
+    addExtensionNames(extensionNames, gltf.extensionsRequired);
+    addExtensionNames(extensionNames, gltfWithRemovedExtensions.extensionsRemoved);
+    addExtensionNames(extensionNames, Object.keys(gltf.extensions || {}));
+    if (gltfWithRemovedExtensions.lights?.length || gltf.nodes.some((node) => "light" in node)) {
+      extensionNames.add("KHR_lights_punctual");
+    }
+    if (gltf.materials.some((material) => {
+      const gltfMaterial = material;
+      return gltfMaterial.unlit || gltfMaterial.extensions?.KHR_materials_unlit;
+    })) {
+      extensionNames.add("KHR_materials_unlit");
+    }
+    return extensionNames;
+  }
+  function addExtensionNames(extensionNames, newExtensionNames = []) {
+    for (const extensionName of newExtensionNames) {
+      extensionNames.add(extensionName);
+    }
+  }
+
   // src/gltf/create-scenegraph-from-gltf.ts
   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);
+  }
   return __toCommonJS(bundle_exports);
 })();
       return __exports__;