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

package/dist/index.cjs

@@ -43,11 +43,11 @@ function loadPBREnvironment(device, props) {
       magFilter: "linear"
     },
     // Texture accepts a promise that returns an image as data (Async Textures)
-    data: (0, import_textures.loadImageTexture)(props.brdfLutUrl)
+    data: (0, import_textures.loadImageTexture)(resolveTextureUrl(props.brdfLutUrl))
   });
   const diffuseEnvSampler = makeCube(device, {
     id: "DiffuseEnvSampler",
-    getTextureForFace: (face) => (0, import_textures.loadImageTexture)(props.getTexUrl("diffuse", FACES.indexOf(face), 0)),
+    getTextureForFace: (face) => (0, import_textures.loadImageTexture)(resolveTextureUrl(props.getTexUrl("diffuse", FACES.indexOf(face), 0))),
     sampler: {
       addressModeU: "clamp-to-edge",
       addressModeV: "clamp-to-edge",
@@ -61,7 +61,7 @@ function loadPBREnvironment(device, props) {
       const imageArray = [];
       const direction = FACES.indexOf(face);
       for (let lod = 0; lod < specularMipLevels; lod++) {
-        imageArray.push((0, import_textures.loadImageTexture)(props.getTexUrl("specular", direction, lod)));
+        imageArray.push((0, import_textures.loadImageTexture)(resolveTextureUrl(props.getTexUrl("specular", direction, lod))));
       }
       return Promise.all(imageArray);
     },
@@ -80,6 +80,11 @@ function loadPBREnvironment(device, props) {
   };
 }
 var FACES = ["+X", "-X", "+Y", "-Y", "+Z", "-Z"];
+function resolveTextureUrl(url) {
+  var _a, _b;
+  const baseUrl = ((_a = globalThis.document) == null ? void 0 : _a.baseURI) ?? ((_b = globalThis.location) == null ? void 0 : _b.href);
+  return baseUrl ? new URL(url, baseUrl).toString() : url;
+}
 function makeCube(device, { id, getTextureForFace, sampler }) {
   const data = Promise.all(FACES.map((face) => getTextureForFace(face))).then((faceDataArray) => {
     const cubeData = {};
@@ -98,7 +103,7 @@ function makeCube(device, { id, getTextureForFace, sampler }) {
 }
 
 // dist/parsers/parse-pbr-material.js
-var import_core = require("@luma.gl/core");
+var import_core2 = require("@luma.gl/core");
 
 // dist/webgl-to-webgpu/gltf-webgl-constants.js
 var GLEnum;
@@ -179,6 +184,87 @@ function convertSamplerMinFilter(mode) {
   }
 }
 
+// dist/pbr/texture-transform.js
+var import_core = require("@math.gl/core");
+var TEXTURE_TRANSFORM_SLOT_DEFINITIONS = [
+  createTextureTransformSlotDefinition("baseColor", "pbr_baseColorSampler", "baseColorTexture", [
+    "pbrMetallicRoughness",
+    "baseColorTexture"
+  ]),
+  createTextureTransformSlotDefinition("metallicRoughness", "pbr_metallicRoughnessSampler", "metallicRoughnessTexture", ["pbrMetallicRoughness", "metallicRoughnessTexture"]),
+  createTextureTransformSlotDefinition("normal", "pbr_normalSampler", "normalTexture", [
+    "normalTexture"
+  ]),
+  createTextureTransformSlotDefinition("occlusion", "pbr_occlusionSampler", "occlusionTexture", [
+    "occlusionTexture"
+  ]),
+  createTextureTransformSlotDefinition("emissive", "pbr_emissiveSampler", "emissiveTexture", [
+    "emissiveTexture"
+  ]),
+  createTextureTransformSlotDefinition("specularColor", "pbr_specularColorSampler", "KHR_materials_specular.specularColorTexture", ["extensions", "KHR_materials_specular", "specularColorTexture"]),
+  createTextureTransformSlotDefinition("specularIntensity", "pbr_specularIntensitySampler", "KHR_materials_specular.specularTexture", ["extensions", "KHR_materials_specular", "specularTexture"]),
+  createTextureTransformSlotDefinition("transmission", "pbr_transmissionSampler", "KHR_materials_transmission.transmissionTexture", ["extensions", "KHR_materials_transmission", "transmissionTexture"]),
+  createTextureTransformSlotDefinition("thickness", "pbr_thicknessSampler", "KHR_materials_volume.thicknessTexture", ["extensions", "KHR_materials_volume", "thicknessTexture"]),
+  createTextureTransformSlotDefinition("clearcoat", "pbr_clearcoatSampler", "KHR_materials_clearcoat.clearcoatTexture", ["extensions", "KHR_materials_clearcoat", "clearcoatTexture"]),
+  createTextureTransformSlotDefinition("clearcoatRoughness", "pbr_clearcoatRoughnessSampler", "KHR_materials_clearcoat.clearcoatRoughnessTexture", ["extensions", "KHR_materials_clearcoat", "clearcoatRoughnessTexture"]),
+  createTextureTransformSlotDefinition("clearcoatNormal", "pbr_clearcoatNormalSampler", "KHR_materials_clearcoat.clearcoatNormalTexture", ["extensions", "KHR_materials_clearcoat", "clearcoatNormalTexture"]),
+  createTextureTransformSlotDefinition("sheenColor", "pbr_sheenColorSampler", "KHR_materials_sheen.sheenColorTexture", ["extensions", "KHR_materials_sheen", "sheenColorTexture"]),
+  createTextureTransformSlotDefinition("sheenRoughness", "pbr_sheenRoughnessSampler", "KHR_materials_sheen.sheenRoughnessTexture", ["extensions", "KHR_materials_sheen", "sheenRoughnessTexture"]),
+  createTextureTransformSlotDefinition("iridescence", "pbr_iridescenceSampler", "KHR_materials_iridescence.iridescenceTexture", ["extensions", "KHR_materials_iridescence", "iridescenceTexture"]),
+  createTextureTransformSlotDefinition("iridescenceThickness", "pbr_iridescenceThicknessSampler", "KHR_materials_iridescence.iridescenceThicknessTexture", ["extensions", "KHR_materials_iridescence", "iridescenceThicknessTexture"]),
+  createTextureTransformSlotDefinition("anisotropy", "pbr_anisotropySampler", "KHR_materials_anisotropy.anisotropyTexture", ["extensions", "KHR_materials_anisotropy", "anisotropyTexture"])
+];
+var TEXTURE_TRANSFORM_SLOT_DEFINITION_MAP = new Map(TEXTURE_TRANSFORM_SLOT_DEFINITIONS.map((definition) => [definition.slot, definition]));
+function createTextureTransformSlotDefinition(slot, binding, displayName, pathSegments) {
+  return {
+    slot,
+    binding,
+    displayName,
+    pathSegments,
+    uvSetUniform: `${slot}UVSet`,
+    uvTransformUniform: `${slot}UVTransform`
+  };
+}
+function getTextureTransformSlotDefinitions() {
+  return TEXTURE_TRANSFORM_SLOT_DEFINITIONS;
+}
+function getTextureTransformSlotDefinition(slot) {
+  const definition = TEXTURE_TRANSFORM_SLOT_DEFINITION_MAP.get(slot);
+  if (!definition) {
+    throw new Error(`Unknown PBR texture transform slot ${slot}`);
+  }
+  return definition;
+}
+function resolveTextureTransform(textureInfo) {
+  var _a;
+  const extensionTextureTransform = (_a = textureInfo == null ? void 0 : textureInfo["extensions"]) == null ? void 0 : _a["KHR_texture_transform"];
+  return {
+    offset: (extensionTextureTransform == null ? void 0 : extensionTextureTransform.offset) ? [extensionTextureTransform.offset[0], extensionTextureTransform.offset[1]] : [0, 0],
+    rotation: (extensionTextureTransform == null ? void 0 : extensionTextureTransform.rotation) ?? 0,
+    scale: (extensionTextureTransform == null ? void 0 : extensionTextureTransform.scale) ? [extensionTextureTransform.scale[0], extensionTextureTransform.scale[1]] : [1, 1]
+  };
+}
+function resolveTextureCoordinateSet(textureInfo) {
+  var _a;
+  const extensionTextureTransform = (_a = textureInfo == null ? void 0 : textureInfo["extensions"]) == null ? void 0 : _a["KHR_texture_transform"];
+  return (extensionTextureTransform == null ? void 0 : extensionTextureTransform["texCoord"]) ?? (textureInfo == null ? void 0 : textureInfo["texCoord"]) ?? 0;
+}
+function resolveTextureTransformSlot(pointerSegments) {
+  return TEXTURE_TRANSFORM_SLOT_DEFINITIONS.find((definition) => definition.pathSegments.length === pointerSegments.length && definition.pathSegments.every((segment, index) => pointerSegments[index] === segment)) || null;
+}
+function getTextureTransformMatrix(transform) {
+  const translationMatrix = new import_core.Matrix3().set(1, 0, 0, 0, 1, 0, transform.offset[0], transform.offset[1], 1);
+  const rotationMatrix = new import_core.Matrix3().set(Math.cos(transform.rotation), Math.sin(transform.rotation), 0, -Math.sin(transform.rotation), Math.cos(transform.rotation), 0, 0, 0, 1);
+  const scaleMatrix = new import_core.Matrix3().set(transform.scale[0], 0, 0, 0, transform.scale[1], 0, 0, 0, 1);
+  return Array.from(translationMatrix.multiplyRight(rotationMatrix).multiplyRight(scaleMatrix));
+}
+function getTextureTransformDeltaMatrix(baseTransform, currentTransform) {
+  const baseMatrix = new import_core.Matrix3(getTextureTransformMatrix(baseTransform));
+  const currentMatrix = new import_core.Matrix3(getTextureTransformMatrix(currentTransform));
+  const inverseBaseMatrix = new import_core.Matrix3(baseMatrix).invert();
+  return Array.from(currentMatrix.multiplyRight(inverseBaseMatrix));
+}
+
 // dist/parsers/parse-pbr-material.js
 function parsePBRMaterial(device, material, attributes, options) {
   const parsedMaterial = {
@@ -219,6 +305,8 @@ function parsePBRMaterial(device, material, attributes, options) {
     parsedMaterial.defines["HAS_TANGENTS"] = true;
   if (attributes["TEXCOORD_0"])
     parsedMaterial.defines["HAS_UV"] = true;
+  if (attributes["TEXCOORD_1"])
+    parsedMaterial.defines["HAS_UV_1"] = true;
   if (attributes["JOINTS_0"] && attributes["WEIGHTS_0"])
     parsedMaterial.defines["HAS_SKIN"] = true;
   if (attributes["COLOR_0"])
@@ -231,75 +319,55 @@ function parsePBRMaterial(device, material, attributes, options) {
     if (options.validateAttributes !== false) {
       warnOnMissingExpectedAttributes(material, attributes);
     }
-    parseMaterial(device, material, parsedMaterial, options.gltf);
+    parseMaterial(device, material, parsedMaterial, attributes, options.gltf);
   }
   return parsedMaterial;
 }
 function warnOnMissingExpectedAttributes(material, attributes) {
   var _a;
-  const uvDependentTextureSlots = getUvDependentTextureSlots(material);
+  const uvDependentTextureSlots = getUvDependentTextureSlots(material, 0);
   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`)();
+    import_core2.log.warn(`glTF material uses ${uvDependentTextureSlots.join(", ")} but primitive is missing TEXCOORD_0; textured shading will sample the default UV coordinates`)();
+  }
+  const uv1DependentTextureSlots = getUvDependentTextureSlots(material, 1);
+  if (uv1DependentTextureSlots.length > 0 && !attributes["TEXCOORD_1"]) {
+    import_core2.log.warn(`glTF material uses ${uv1DependentTextureSlots.join(", ")} with TEXCOORD_1 but primitive is missing TEXCOORD_1; those textures will be skipped`)();
   }
   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`)();
+  import_core2.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;
+function getUvDependentTextureSlots(material, textureCoordinateSet) {
   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");
+  for (const slotDefinition of getTextureTransformSlotDefinitions()) {
+    const textureInfo = getNestedTextureInfo(material, slotDefinition.pathSegments);
+    if (!textureInfo) {
+      continue;
+    }
+    if (resolveTextureCoordinateSet(textureInfo) === textureCoordinateSet) {
+      uvDependentTextureSlots.push(slotDefinition.displayName);
+    }
   }
   return uvDependentTextureSlots;
 }
-function parseMaterial(device, material, parsedMaterial, gltf) {
+function getNestedTextureInfo(material, pathSegments) {
+  let value = material;
+  for (const pathSegment of pathSegments) {
+    value = value == null ? void 0 : value[pathSegment];
+    if (!value) {
+      return null;
+    }
+  }
+  return value;
+}
+function parseMaterial(device, material, parsedMaterial, attributes, 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, gltf);
+    parsePbrMetallicRoughness(device, material.pbrMetallicRoughness, parsedMaterial, attributes, gltf);
   }
   if (material.normalTexture) {
     addTexture(device, material.normalTexture, "pbr_normalSampler", parsedMaterial, {
@@ -307,7 +375,9 @@ function parseMaterial(device, material, parsedMaterial, gltf) {
         define: "HAS_NORMALMAP",
         enabledUniformName: "normalMapEnabled"
       },
-      gltf
+      gltf,
+      attributes,
+      textureTransformSlot: "normal"
     });
     const { scale = 1 } = material.normalTexture;
     parsedMaterial.uniforms.normalScale = scale;
@@ -318,7 +388,9 @@ function parseMaterial(device, material, parsedMaterial, gltf) {
         define: "HAS_OCCLUSIONMAP",
         enabledUniformName: "occlusionMapEnabled"
       },
-      gltf
+      gltf,
+      attributes,
+      textureTransformSlot: "occlusion"
     });
     const { strength = 1 } = material.occlusionTexture;
     parsedMaterial.uniforms.occlusionStrength = strength;
@@ -330,10 +402,12 @@ function parseMaterial(device, material, parsedMaterial, gltf) {
         define: "HAS_EMISSIVEMAP",
         enabledUniformName: "emissiveMapEnabled"
       },
-      gltf
+      gltf,
+      attributes,
+      textureTransformSlot: "emissive"
     });
   }
-  parseMaterialExtensions(device, material.extensions, parsedMaterial, gltf);
+  parseMaterialExtensions(device, material.extensions, parsedMaterial, gltf, attributes);
   switch (material.alphaMode || "OPAQUE") {
     case "OPAQUE":
       break;
@@ -345,7 +419,7 @@ function parseMaterial(device, material, parsedMaterial, gltf) {
       break;
     }
     case "BLEND":
-      import_core.log.warn("glTF BLEND alphaMode might not work well because it requires mesh sorting")();
+      import_core2.log.warn("glTF BLEND alphaMode might not work well because it requires mesh sorting")();
       applyAlphaBlendParameters(parsedMaterial);
       break;
   }
@@ -386,14 +460,16 @@ function applyTransmissionBlendApproximation(parsedMaterial) {
     GLEnum.ONE_MINUS_SRC_ALPHA
   ];
 }
-function parsePbrMetallicRoughness(device, pbrMetallicRoughness, parsedMaterial, gltf) {
+function parsePbrMetallicRoughness(device, pbrMetallicRoughness, parsedMaterial, attributes, gltf) {
   if (pbrMetallicRoughness.baseColorTexture) {
     addTexture(device, pbrMetallicRoughness.baseColorTexture, "pbr_baseColorSampler", parsedMaterial, {
       featureOptions: {
         define: "HAS_BASECOLORMAP",
         enabledUniformName: "baseColorMapEnabled"
       },
-      gltf
+      gltf,
+      attributes,
+      textureTransformSlot: "baseColor"
     });
   }
   parsedMaterial.uniforms.baseColorFactor = pbrMetallicRoughness.baseColorFactor || [1, 1, 1, 1];
@@ -403,33 +479,35 @@ function parsePbrMetallicRoughness(device, pbrMetallicRoughness, parsedMaterial,
         define: "HAS_METALROUGHNESSMAP",
         enabledUniformName: "metallicRoughnessMapEnabled"
       },
-      gltf
+      gltf,
+      attributes,
+      textureTransformSlot: "metallicRoughness"
     });
   }
   const { metallicFactor = 1, roughnessFactor = 1 } = pbrMetallicRoughness;
   parsedMaterial.uniforms.metallicRoughnessValues = [metallicFactor, roughnessFactor];
 }
-function parseMaterialExtensions(device, extensions, parsedMaterial, gltf) {
+function parseMaterialExtensions(device, extensions, parsedMaterial, gltf, attributes = {}) {
   if (!extensions) {
     return;
   }
   if (hasMaterialExtensionShading(extensions)) {
     parsedMaterial.defines["USE_MATERIAL_EXTENSIONS"] = true;
   }
-  parseSpecularExtension(device, extensions.KHR_materials_specular, parsedMaterial, gltf);
+  parseSpecularExtension(device, extensions.KHR_materials_specular, parsedMaterial, gltf, attributes);
   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);
+  parseTransmissionExtension(device, extensions.KHR_materials_transmission, parsedMaterial, gltf, attributes);
+  parseVolumeExtension(device, extensions.KHR_materials_volume, parsedMaterial, gltf, attributes);
+  parseClearcoatExtension(device, extensions.KHR_materials_clearcoat, parsedMaterial, gltf, attributes);
+  parseSheenExtension(device, extensions.KHR_materials_sheen, parsedMaterial, gltf, attributes);
+  parseIridescenceExtension(device, extensions.KHR_materials_iridescence, parsedMaterial, gltf, attributes);
+  parseAnisotropyExtension(device, extensions.KHR_materials_anisotropy, parsedMaterial, gltf, attributes);
   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) {
+function parseSpecularExtension(device, extension, parsedMaterial, gltf, attributes = {}) {
   if (!extension) {
     return;
   }
@@ -445,7 +523,9 @@ function parseSpecularExtension(device, extension, parsedMaterial, gltf) {
         define: "HAS_SPECULARCOLORMAP",
         enabledUniformName: "specularColorMapEnabled"
       },
-      gltf
+      gltf,
+      attributes,
+      textureTransformSlot: "specularColor"
     });
   }
   if (extension.specularTexture) {
@@ -454,7 +534,9 @@ function parseSpecularExtension(device, extension, parsedMaterial, gltf) {
         define: "HAS_SPECULARINTENSITYMAP",
         enabledUniformName: "specularIntensityMapEnabled"
       },
-      gltf
+      gltf,
+      attributes,
+      textureTransformSlot: "specularIntensity"
     });
   }
 }
@@ -463,7 +545,7 @@ function parseIorExtension(extension, parsedMaterial) {
     parsedMaterial.uniforms.ior = extension.ior;
   }
 }
-function parseTransmissionExtension(device, extension, parsedMaterial, gltf) {
+function parseTransmissionExtension(device, extension, parsedMaterial, gltf, attributes = {}) {
   if (!extension) {
     return;
   }
@@ -476,15 +558,17 @@ function parseTransmissionExtension(device, extension, parsedMaterial, gltf) {
         define: "HAS_TRANSMISSIONMAP",
         enabledUniformName: "transmissionMapEnabled"
       },
-      gltf
+      gltf,
+      attributes,
+      textureTransformSlot: "transmission"
     });
   }
   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")();
+    import_core2.log.warn("KHR_materials_transmission uses a premultiplied-alpha blending approximation and may require mesh sorting")();
     applyTransmissionBlendApproximation(parsedMaterial);
   }
 }
-function parseVolumeExtension(device, extension, parsedMaterial, gltf) {
+function parseVolumeExtension(device, extension, parsedMaterial, gltf, attributes = {}) {
   if (!extension) {
     return;
   }
@@ -496,7 +580,9 @@ function parseVolumeExtension(device, extension, parsedMaterial, gltf) {
       featureOptions: {
         define: "HAS_THICKNESSMAP"
       },
-      gltf
+      gltf,
+      attributes,
+      textureTransformSlot: "thickness"
     });
   }
   if (extension.attenuationDistance !== void 0) {
@@ -506,7 +592,7 @@ function parseVolumeExtension(device, extension, parsedMaterial, gltf) {
     parsedMaterial.uniforms.attenuationColor = extension.attenuationColor;
   }
 }
-function parseClearcoatExtension(device, extension, parsedMaterial, gltf) {
+function parseClearcoatExtension(device, extension, parsedMaterial, gltf, attributes = {}) {
   if (!extension) {
     return;
   }
@@ -522,7 +608,9 @@ function parseClearcoatExtension(device, extension, parsedMaterial, gltf) {
         define: "HAS_CLEARCOATMAP",
         enabledUniformName: "clearcoatMapEnabled"
       },
-      gltf
+      gltf,
+      attributes,
+      textureTransformSlot: "clearcoat"
     });
   }
   if (extension.clearcoatRoughnessTexture) {
@@ -531,7 +619,9 @@ function parseClearcoatExtension(device, extension, parsedMaterial, gltf) {
         define: "HAS_CLEARCOATROUGHNESSMAP",
         enabledUniformName: "clearcoatRoughnessMapEnabled"
       },
-      gltf
+      gltf,
+      attributes,
+      textureTransformSlot: "clearcoatRoughness"
     });
   }
   if (extension.clearcoatNormalTexture) {
@@ -539,11 +629,13 @@ function parseClearcoatExtension(device, extension, parsedMaterial, gltf) {
       featureOptions: {
         define: "HAS_CLEARCOATNORMALMAP"
       },
-      gltf
+      gltf,
+      attributes,
+      textureTransformSlot: "clearcoatNormal"
     });
   }
 }
-function parseSheenExtension(device, extension, parsedMaterial, gltf) {
+function parseSheenExtension(device, extension, parsedMaterial, gltf, attributes = {}) {
   if (!extension) {
     return;
   }
@@ -559,7 +651,9 @@ function parseSheenExtension(device, extension, parsedMaterial, gltf) {
         define: "HAS_SHEENCOLORMAP",
         enabledUniformName: "sheenColorMapEnabled"
       },
-      gltf
+      gltf,
+      attributes,
+      textureTransformSlot: "sheenColor"
     });
   }
   if (extension.sheenRoughnessTexture) {
@@ -568,11 +662,13 @@ function parseSheenExtension(device, extension, parsedMaterial, gltf) {
         define: "HAS_SHEENROUGHNESSMAP",
         enabledUniformName: "sheenRoughnessMapEnabled"
       },
-      gltf
+      gltf,
+      attributes,
+      textureTransformSlot: "sheenRoughness"
     });
   }
 }
-function parseIridescenceExtension(device, extension, parsedMaterial, gltf) {
+function parseIridescenceExtension(device, extension, parsedMaterial, gltf, attributes = {}) {
   if (!extension) {
     return;
   }
@@ -594,7 +690,9 @@ function parseIridescenceExtension(device, extension, parsedMaterial, gltf) {
         define: "HAS_IRIDESCENCEMAP",
         enabledUniformName: "iridescenceMapEnabled"
       },
-      gltf
+      gltf,
+      attributes,
+      textureTransformSlot: "iridescence"
     });
   }
   if (extension.iridescenceThicknessTexture) {
@@ -602,11 +700,13 @@ function parseIridescenceExtension(device, extension, parsedMaterial, gltf) {
       featureOptions: {
         define: "HAS_IRIDESCENCETHICKNESSMAP"
       },
-      gltf
+      gltf,
+      attributes,
+      textureTransformSlot: "iridescenceThickness"
     });
   }
 }
-function parseAnisotropyExtension(device, extension, parsedMaterial, gltf) {
+function parseAnisotropyExtension(device, extension, parsedMaterial, gltf, attributes = {}) {
   if (!extension) {
     return;
   }
@@ -622,7 +722,9 @@ function parseAnisotropyExtension(device, extension, parsedMaterial, gltf) {
         define: "HAS_ANISOTROPYMAP",
         enabledUniformName: "anisotropyMapEnabled"
       },
-      gltf
+      gltf,
+      attributes,
+      textureTransformSlot: "anisotropy"
     });
   }
 }
@@ -633,12 +735,21 @@ function parseEmissiveStrengthExtension(extension, parsedMaterial) {
 }
 function addTexture(device, gltfTexture, uniformName, parsedMaterial, textureParseOptions = {}) {
   var _a, _b, _c;
-  const { featureOptions = {}, gltf } = textureParseOptions;
+  const { featureOptions = {}, gltf, attributes = {}, textureTransformSlot } = textureParseOptions;
   const { define, enabledUniformName } = featureOptions;
+  const textureCoordinateSet = resolveTextureCoordinateSet(gltfTexture);
+  if (textureCoordinateSet > 1) {
+    import_core2.log.warn(`Skipping ${String(uniformName)} because ${textureCoordinateSet} is not supported; only TEXCOORD_0 and TEXCOORD_1 are currently available`)();
+    return;
+  }
+  if (textureCoordinateSet === 1 && !attributes["TEXCOORD_1"]) {
+    import_core2.log.warn(`Skipping ${String(uniformName)} because it requires TEXCOORD_1 but the primitive does not provide TEXCOORD_1`)();
+    return;
+  }
   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)}`)();
+    import_core2.log.warn(`Skipping unresolved glTF texture for ${String(uniformName)}`)();
     return;
   }
   const gltfSampler = {
@@ -674,6 +785,11 @@ function addTexture(device, gltfTexture, uniformName, parsedMaterial, texturePar
   if (enabledUniformName) {
     parsedMaterial.uniforms[enabledUniformName] = true;
   }
+  if (textureTransformSlot) {
+    const textureTransformSlotDefinition = getTextureTransformSlotDefinition(textureTransformSlot);
+    parsedMaterial.uniforms[textureTransformSlotDefinition.uvSetUniform] = textureCoordinateSet;
+    parsedMaterial.uniforms[textureTransformSlotDefinition.uvTransformUniform] = getTextureTransformMatrix(resolveTextureTransform(gltfTexture));
+  }
   parsedMaterial.generatedTextures.push(texture);
 }
 function resolveTextureInfo(gltfTexture, gltf) {
@@ -712,7 +828,7 @@ function resolveCompressedTextureFormat(level) {
   return level.textureFormat;
 }
 function getMaxCompressedMipLevels(baseWidth, baseHeight, format) {
-  const { blockWidth = 1, blockHeight = 1 } = import_core.textureFormatDecoder.getInfo(format);
+  const { blockWidth = 1, blockHeight = 1 } = import_core2.textureFormatDecoder.getInfo(format);
   let count = 1;
   for (let i = 1; ; i++) {
     const w = Math.max(1, baseWidth >> i);
@@ -734,19 +850,19 @@ function createCompressedTexture(device, image, baseOptions) {
     levels = [];
   }
   if (levels.length === 0 || !((_b = levels[0]) == null ? void 0 : _b.data)) {
-    import_core.log.warn("createCompressedTexture: compressed image has no valid mip levels, creating fallback")();
+    import_core2.log.warn("createCompressedTexture: compressed image has no valid mip levels, creating fallback")();
     return createCompressedTextureFallback(device, baseOptions);
   }
   const baseLevel = levels[0];
   const baseWidth = baseLevel.width ?? image.width ?? 0;
   const baseHeight = baseLevel.height ?? image.height ?? 0;
   if (baseWidth <= 0 || baseHeight <= 0) {
-    import_core.log.warn("createCompressedTexture: base level has invalid dimensions, creating fallback")();
+    import_core2.log.warn("createCompressedTexture: base level has invalid dimensions, creating fallback")();
     return createCompressedTextureFallback(device, baseOptions);
   }
   const format = resolveCompressedTextureFormat(baseLevel);
   if (!format) {
-    import_core.log.warn("createCompressedTexture: compressed image has no textureFormat, creating fallback")();
+    import_core2.log.warn("createCompressedTexture: compressed image has no textureFormat, creating fallback")();
     return createCompressedTextureFallback(device, baseOptions);
   }
   const maxMipLevels = getMaxCompressedMipLevels(baseWidth, baseHeight, format);
@@ -755,18 +871,18 @@ function createCompressedTexture(device, image, baseOptions) {
   for (let i = 1; i < levelLimit; i++) {
     const level = levels[i];
     if (!level.data || level.width <= 0 || level.height <= 0) {
-      import_core.log.warn(`createCompressedTexture: mip level ${i} has invalid data/dimensions, truncating`)();
+      import_core2.log.warn(`createCompressedTexture: mip level ${i} has invalid data/dimensions, truncating`)();
       break;
     }
     const levelFormat = resolveCompressedTextureFormat(level);
     if (levelFormat && levelFormat !== format) {
-      import_core.log.warn(`createCompressedTexture: mip level ${i} format '${levelFormat}' differs from base '${format}', truncating`)();
+      import_core2.log.warn(`createCompressedTexture: mip level ${i} format '${levelFormat}' differs from base '${format}', truncating`)();
       break;
     }
     const expectedW = Math.max(1, baseWidth >> i);
     const expectedH = Math.max(1, baseHeight >> i);
     if (level.width !== expectedW || level.height !== expectedH) {
-      import_core.log.warn(`createCompressedTexture: mip level ${i} dimensions ${level.width}x${level.height} don't match expected ${expectedW}x${expectedH}, truncating`)();
+      import_core2.log.warn(`createCompressedTexture: mip level ${i} dimensions ${level.width}x${level.height} don't match expected ${expectedW}x${expectedH}, truncating`)();
       break;
     }
     validLevelCount++;
@@ -774,7 +890,7 @@ function createCompressedTexture(device, image, baseOptions) {
   const texture = device.createTexture({
     ...baseOptions,
     format,
-    usage: import_core.Texture.TEXTURE | import_core.Texture.COPY_DST,
+    usage: import_core2.Texture.TEXTURE | import_core2.Texture.COPY_DST,
     width: baseWidth,
     height: baseHeight,
     mipLevels: validLevelCount,
@@ -791,9 +907,9 @@ 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 import_core3 = require("@math.gl/core");
+var import_shadertools = require("@luma.gl/shadertools");
+function parseGLTFLights(gltf, options = {}) {
   var _a, _b, _c, _d;
   const lightDefs = (
     // `postProcessGLTF()` moves KHR_lights_punctual into `gltf.lights`.
@@ -814,7 +930,7 @@ function parseGLTFLights(gltf) {
     if (!gltfLight) {
       continue;
     }
-    const color = normalizeGLTFLightColor(gltfLight.color || [1, 1, 1]);
+    const color = normalizeGLTFLightColor(gltfLight.color || [1, 1, 1], options.useByteColors ?? true);
     const intensity = gltfLight.intensity ?? 1;
     const range = gltfLight.range;
     const worldMatrix = getNodeWorldMatrix(node, parentNodeById, worldMatrixByNodeId);
@@ -834,8 +950,11 @@ function parseGLTFLights(gltf) {
   }
   return lights;
 }
-function normalizeGLTFLightColor(color) {
-  return color.map((component) => component * GLTF_COLOR_FACTOR);
+function normalizeGLTFLightColor(color, useByteColors) {
+  if (useByteColors) {
+    return color.map((component) => component * 255);
+  }
+  return (0, import_shadertools.normalizeByteColor3)(color, false);
 }
 function parsePointLight(worldMatrix, color, intensity, range) {
   const position = getLightPosition(worldMatrix);
@@ -894,20 +1013,20 @@ function getNodeWorldMatrix(node, parentNodeById, worldMatrixByNodeId) {
   }
   const localMatrix = getNodeLocalMatrix(node);
   const parentNode = parentNodeById.get(node.id);
-  const worldMatrix = parentNode ? new import_core2.Matrix4(getNodeWorldMatrix(parentNode, parentNodeById, worldMatrixByNodeId)).multiplyRight(localMatrix) : localMatrix;
+  const worldMatrix = parentNode ? new import_core3.Matrix4(getNodeWorldMatrix(parentNode, parentNodeById, worldMatrixByNodeId)).multiplyRight(localMatrix) : localMatrix;
   worldMatrixByNodeId.set(node.id, worldMatrix);
   return worldMatrix;
 }
 function getNodeLocalMatrix(node) {
   if (node.matrix) {
-    return new import_core2.Matrix4(node.matrix);
+    return new import_core3.Matrix4(node.matrix);
   }
-  const matrix = new import_core2.Matrix4();
+  const matrix = new import_core3.Matrix4();
   if (node.translation) {
     matrix.translate(node.translation);
   }
   if (node.rotation) {
-    matrix.multiplyRight(new import_core2.Matrix4().fromQuaternion(node.rotation));
+    matrix.multiplyRight(new import_core3.Matrix4().fromQuaternion(node.rotation));
   }
   if (node.scale) {
     matrix.scale(node.scale);
@@ -923,7 +1042,7 @@ function getLightDirection(worldMatrix) {
 
 // dist/parsers/parse-gltf.js
 var import_engine4 = require("@luma.gl/engine");
-var import_shadertools2 = require("@luma.gl/shadertools");
+var import_shadertools3 = require("@luma.gl/shadertools");
 
 // dist/webgl-to-webgpu/convert-webgl-topology.js
 function convertGLDrawModeToTopology(drawMode) {
@@ -944,9 +1063,9 @@ function convertGLDrawModeToTopology(drawMode) {
 }
 
 // dist/gltf/create-gltf-model.js
-var import_core3 = require("@luma.gl/core");
+var import_core4 = require("@luma.gl/core");
 var import_engine2 = require("@luma.gl/engine");
-var import_shadertools = require("@luma.gl/shadertools");
+var import_shadertools2 = require("@luma.gl/shadertools");
 var import_engine3 = require("@luma.gl/engine");
 var SHADER = (
   /* WGSL */
@@ -962,19 +1081,23 @@ struct VertexInputs {
 #ifdef HAS_UV
   @location(3) texCoords: vec2f,
 #endif
+#ifdef HAS_UV_1
+  @location(4) texCoords1: vec2f,
+#endif
 #ifdef HAS_SKIN
-  @location(4) JOINTS_0: vec4u,
-  @location(5) WEIGHTS_0: vec4f,
+  @location(5) JOINTS_0: vec4u,
+  @location(6) WEIGHTS_0: vec4f,
 #endif
 };
 
 struct FragmentInputs {
   @builtin(position) position: vec4f,
   @location(0) pbrPosition: vec3f,
-  @location(1) pbrUV: vec2f,
-  @location(2) pbrNormal: vec3f,
+  @location(1) pbrUV0: vec2f,
+  @location(2) pbrUV1: vec2f,
+  @location(3) pbrNormal: vec3f,
 #ifdef HAS_TANGENTS
-  @location(3) pbrTangent: vec4f,
+  @location(4) pbrTangent: vec4f,
 #endif
 };
 
@@ -984,13 +1107,17 @@ fn vertexMain(inputs: VertexInputs) -> FragmentInputs {
   var position = vec4f(inputs.positions, 1.0);
   var normal = vec3f(0.0, 0.0, 1.0);
   var tangent = vec4f(1.0, 0.0, 0.0, 1.0);
-  var uv = vec2f(0.0, 0.0);
+  var uv0 = vec2f(0.0, 0.0);
+  var uv1 = vec2f(0.0, 0.0);
 
 #ifdef HAS_NORMALS
   normal = inputs.normals;
 #endif
 #ifdef HAS_UV
-  uv = inputs.texCoords;
+  uv0 = inputs.texCoords;
+#endif
+#ifdef HAS_UV_1
+  uv1 = inputs.texCoords1;
 #endif
 #ifdef HAS_TANGENTS
   tangent = inputs.TANGENT;
@@ -1016,7 +1143,8 @@ fn vertexMain(inputs: VertexInputs) -> FragmentInputs {
 
   outputs.position = pbrProjection.modelViewProjectionMatrix * position;
   outputs.pbrPosition = worldPosition.xyz / worldPosition.w;
-  outputs.pbrUV = uv;
+  outputs.pbrUV0 = uv0;
+  outputs.pbrUV1 = uv1;
   outputs.pbrNormal = normal;
   return outputs;
 }
@@ -1024,7 +1152,8 @@ fn vertexMain(inputs: VertexInputs) -> FragmentInputs {
 @fragment
 fn fragmentMain(inputs: FragmentInputs) -> @location(0) vec4f {
   fragmentInputs.pbr_vPosition = inputs.pbrPosition;
-  fragmentInputs.pbr_vUV = inputs.pbrUV;
+  fragmentInputs.pbr_vUV0 = inputs.pbrUV0;
+  fragmentInputs.pbr_vUV1 = inputs.pbrUV1;
   fragmentInputs.pbr_vNormal = inputs.pbrNormal;
 #ifdef HAS_TANGENTS
   let tangent = normalize(inputs.pbrTangent.xyz);
@@ -1056,6 +1185,10 @@ var vs = (
     in vec2 texCoords;
   #endif
 
+  #ifdef HAS_UV_1
+    in vec2 texCoords1;
+  #endif
+
   #ifdef HAS_SKIN
     in uvec4 JOINTS_0;
     in vec4 WEIGHTS_0;
@@ -1065,6 +1198,7 @@ var vs = (
     vec4 _NORMAL = vec4(0.);
     vec4 _TANGENT = vec4(0.);
     vec2 _TEXCOORD_0 = vec2(0.);
+    vec2 _TEXCOORD_1 = vec2(0.);
 
     #ifdef HAS_NORMALS
       _NORMAL = normals;
@@ -1078,6 +1212,10 @@ var vs = (
       _TEXCOORD_0 = texCoords;
     #endif
 
+    #ifdef HAS_UV_1
+      _TEXCOORD_1 = texCoords1;
+    #endif
+
     vec4 pos = positions;
 
     #ifdef HAS_SKIN
@@ -1087,7 +1225,7 @@ var vs = (
       _TANGENT = vec4((skinMat * vec4(_TANGENT.xyz, 0.)).xyz, _TANGENT.w);
     #endif
 
-    pbr_setPositionNormalTangentUV(pos, _NORMAL, _TANGENT, _TEXCOORD_0);
+    pbr_setPositionNormalTangentUV(pos, _NORMAL, _TANGENT, _TEXCOORD_0, _TEXCOORD_1);
     gl_Position = pbrProjection.modelViewProjectionMatrix * pos;
   }
 `
@@ -1104,7 +1242,7 @@ var fs = (
 `
 );
 function createGLTFMaterial(device, options) {
-  const materialFactory = options.materialFactory || new import_engine3.MaterialFactory(device, { modules: [import_shadertools.pbrMaterial] });
+  const materialFactory = options.materialFactory || new import_engine3.MaterialFactory(device, { modules: [import_shadertools2.pbrMaterial] });
   const pbrMaterialProps = { ...options.parsedPPBRMaterial.uniforms };
   delete pbrMaterialProps.camera;
   const materialBindings = Object.fromEntries(Object.entries({
@@ -1120,7 +1258,7 @@ function createGLTFMaterial(device, options) {
 }
 function createGLTFModel(device, options) {
   const { id, geometry, parsedPPBRMaterial, vertexCount, modelOptions = {} } = options;
-  import_core3.log.info(4, "createGLTFModel defines: ", parsedPPBRMaterial.defines)();
+  import_core4.log.info(4, "createGLTFModel defines: ", parsedPPBRMaterial.defines)();
   const managedResources = [];
   const parameters = {
     depthWriteEnabled: true,
@@ -1136,7 +1274,7 @@ function createGLTFModel(device, options) {
     geometry,
     topology: geometry.topology,
     vertexCount,
-    modules: [import_shadertools.pbrMaterial, import_shadertools.skin],
+    modules: [import_shadertools2.pbrMaterial, import_shadertools2.skin],
     ...modelOptions,
     defines: { ...parsedPPBRMaterial.defines, ...modelOptions.defines },
     parameters: { ...parameters, ...parsedPPBRMaterial.parameters, ...modelOptions.parameters }
@@ -1158,7 +1296,7 @@ function createGLTFModel(device, options) {
   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;
+  return value instanceof import_core4.Buffer || value instanceof import_engine2.DynamicTexture || value instanceof import_core4.Sampler || value instanceof import_core4.Texture || value instanceof import_core4.TextureView;
 }
 function getSceneShaderInputProps(modules, material, shaderInputValues) {
   const propertyToModuleNameMap = /* @__PURE__ */ new Map();
@@ -1191,11 +1329,12 @@ var defaultOptions = {
   pbrDebug: false,
   imageBasedLightingEnvironment: void 0,
   lights: true,
-  useTangents: false
+  useTangents: false,
+  useByteColors: true
 };
 function parseGLTF(device, gltf, options = {}) {
   const combinedOptions = { ...defaultOptions, ...options };
-  const materialFactory = new import_engine4.MaterialFactory(device, { modules: [import_shadertools2.pbrMaterial] });
+  const materialFactory = new import_engine4.MaterialFactory(device, { modules: [import_shadertools3.pbrMaterial] });
   const materials = (gltf.materials || []).map((gltfMaterial, materialIndex) => createGLTFMaterial(device, {
     id: getGLTFMaterialId(gltfMaterial, materialIndex),
     parsedPPBRMaterial: parsePBRMaterial(device, gltfMaterial, {}, {
@@ -1279,7 +1418,7 @@ function createNodeForGLTFMesh(device, gltfMesh, gltf, gltfMaterialIdToMaterialM
 }
 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 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, {
@@ -1288,7 +1427,7 @@ function createNodeForGLTFPrimitive({ device, gltfPrimitive, primitiveIndex, glt
   });
   const modelNode = createGLTFModel(device, {
     id,
-    geometry: createGeometry(id, gltfPrimitive, topology),
+    geometry,
     material: gltfPrimitive.material ? gltfMaterialIdToMaterialMap.get(gltfPrimitive.material.id) || null : null,
     parsedPPBRMaterial,
     modelOptions: options.modelOptions,
@@ -1298,18 +1437,32 @@ function createNodeForGLTFPrimitive({ device, gltfPrimitive, primitiveIndex, glt
   return modelNode;
 }
 function getVertexCount(attributes) {
-  throw new Error("getVertexCount not implemented");
+  let vertexCount = Infinity;
+  for (const attribute of Object.values(attributes)) {
+    if (attribute) {
+      const { value, size, components } = attribute;
+      const attributeSize = size ?? components;
+      if ((value == null ? void 0 : value.length) !== void 0 && attributeSize >= 1) {
+        vertexCount = Math.min(vertexCount, value.length / attributeSize);
+      }
+    }
+  }
+  if (!Number.isFinite(vertexCount)) {
+    throw new Error("Could not determine vertex count from attributes");
+  }
+  return vertexCount;
 }
 function createGeometry(id, gltfPrimitive, topology) {
+  var _a;
   const attributes = {};
   for (const [attributeName, attribute] of Object.entries(gltfPrimitive.attributes)) {
-    const { components, size, value } = attribute;
-    attributes[attributeName] = { size: size ?? components, value };
+    const { components, size, value, normalized } = attribute;
+    attributes[attributeName] = { size: size ?? components, value, normalized };
   }
   return new import_engine4.Geometry({
     id,
     topology,
-    indices: gltfPrimitive.indices.value,
+    indices: (_a = gltfPrimitive.indices) == null ? void 0 : _a.value,
     attributes
   });
 }
@@ -1318,11 +1471,11 @@ function getGLTFMaterialId(gltfMaterial, materialIndex) {
 }
 
 // dist/gltf/gltf-animator.js
-var import_core6 = require("@luma.gl/core");
+var import_core7 = require("@luma.gl/core");
 
 // dist/gltf/animations/interpolate.js
-var import_core4 = require("@luma.gl/core");
-var import_core5 = require("@math.gl/core");
+var import_core5 = require("@luma.gl/core");
+var import_core6 = require("@math.gl/core");
 function updateTargetPath(target, path, newValue) {
   switch (path) {
     case "translation":
@@ -1332,27 +1485,38 @@ function updateTargetPath(target, path, newValue) {
     case "scale":
       return target.setScale(newValue).updateMatrix();
     default:
-      import_core4.log.warn(`Bad animation path ${path}`)();
+      import_core5.log.warn(`Bad animation path ${path}`)();
       return null;
   }
 }
 function interpolate(time, { input, interpolation, output }, target, path) {
+  const value = evaluateSampler(time, { input, interpolation, output }, path);
+  if (value) {
+    updateTargetPath(target, path, value);
+  }
+}
+function evaluateSampler(time, { input, interpolation, output }, path) {
   const maxTime = input[input.length - 1];
+  if (!Number.isFinite(maxTime) || maxTime <= 0) {
+    return output[0] || null;
+  }
   const animationTime = time % maxTime;
   const nextIndex = input.findIndex((t) => t >= animationTime);
+  if (nextIndex < 0) {
+    return output[output.length - 1] || null;
+  }
   const previousIndex = Math.max(0, nextIndex - 1);
   const previousTime = input[previousIndex];
   const nextTime = input[nextIndex];
   switch (interpolation) {
     case "STEP":
-      stepInterpolate(target, path, output[previousIndex]);
-      break;
+      return output[previousIndex];
     case "LINEAR":
       if (nextTime > previousTime) {
         const ratio = (animationTime - previousTime) / (nextTime - previousTime);
-        linearInterpolate(target, path, output[previousIndex], output[nextIndex], ratio);
+        return linearInterpolate(path, output[previousIndex], output[nextIndex], ratio);
       }
-      break;
+      return output[previousIndex] || null;
     case "CUBICSPLINE":
       if (nextTime > previousTime) {
         const ratio = (animationTime - previousTime) / (nextTime - previousTime);
@@ -1361,36 +1525,32 @@ function interpolate(time, { input, interpolation, output }, target, path) {
         const outTangent0 = output[3 * previousIndex + 2];
         const inTangent1 = output[3 * nextIndex + 0];
         const p1 = output[3 * nextIndex + 1];
-        cubicsplineInterpolate(target, path, { p0, outTangent0, inTangent1, p1, tDiff, ratio });
+        return cubicsplineInterpolate({ p0, outTangent0, inTangent1, p1, tDiff, ratio });
       }
-      break;
+      return output[3 * previousIndex + 1] || null;
     default:
-      import_core4.log.warn(`Interpolation ${interpolation} not supported`)();
-      break;
+      import_core5.log.warn(`Interpolation ${interpolation} not supported`)();
+      return null;
   }
 }
-function linearInterpolate(target, path, start, stop, ratio) {
+function linearInterpolate(path, start, stop, ratio) {
   if (path === "rotation") {
-    updateTargetPath(target, path, new import_core5.Quaternion().slerp({ start, target: stop, ratio }));
-  } else {
-    const newVal = [];
-    for (let i = 0; i < start.length; i++) {
-      newVal[i] = ratio * stop[i] + (1 - ratio) * start[i];
-    }
-    updateTargetPath(target, path, newVal);
+    return new import_core6.Quaternion().slerp({ start, target: stop, ratio });
+  }
+  const newVal = [];
+  for (let i = 0; i < start.length; i++) {
+    newVal[i] = ratio * stop[i] + (1 - ratio) * start[i];
   }
+  return newVal;
 }
-function cubicsplineInterpolate(target, path, { p0, outTangent0, inTangent1, p1, tDiff, ratio: t }) {
+function cubicsplineInterpolate({ p0, outTangent0, inTangent1, p1, tDiff, ratio: t }) {
   const newVal = [];
   for (let i = 0; i < p0.length; i++) {
     const m0 = outTangent0[i] * tDiff;
     const m1 = inTangent1[i] * tDiff;
     newVal[i] = (2 * Math.pow(t, 3) - 3 * Math.pow(t, 2) + 1) * p0[i] + (Math.pow(t, 3) - 2 * Math.pow(t, 2) + t) * m0 + (-2 * Math.pow(t, 3) + 3 * Math.pow(t, 2)) * p1[i] + (Math.pow(t, 3) - Math.pow(t, 2)) * m1;
   }
-  updateTargetPath(target, path, newVal);
-}
-function stepInterpolate(target, path, value) {
-  updateTargetPath(target, path, value);
+  return newVal;
 }
 
 // dist/gltf/gltf-animator.js
@@ -1399,18 +1559,26 @@ var GLTFSingleAnimator = class {
   animation;
   /** Target scenegraph lookup table. */
   gltfNodeIdToNodeMap;
+  /** Materials aligned with the source glTF materials array. */
+  materials;
   /** Playback start time in seconds. */
   startTime = 0;
   /** Whether playback is currently enabled. */
   playing = true;
   /** Playback speed multiplier. */
   speed = 1;
+  /** Mutable runtime texture-transform state for animated material slots. */
+  materialTextureTransformState = /* @__PURE__ */ new Map();
   /** Creates a single-animation controller. */
   constructor(props) {
     this.animation = props.animation;
     this.gltfNodeIdToNodeMap = props.gltfNodeIdToNodeMap;
+    this.materials = props.materials || [];
     this.animation.name ||= "unnamed";
     Object.assign(this, props);
+    if (this.animation.channels.some((channel) => channel.type !== "node") && !this.materials.length) {
+      throw new Error(`Animation ${this.animation.name} targets materials, but GLTFAnimator was created without a materials array`);
+    }
   }
   /** Advances the animation to the supplied wall-clock time in milliseconds. */
   setTime(timeMs) {
@@ -1419,12 +1587,28 @@ var GLTFSingleAnimator = class {
     }
     const absTime = timeMs / 1e3;
     const time = (absTime - this.startTime) * this.speed;
-    this.animation.channels.forEach(({ sampler, targetNodeId, path }) => {
-      const targetNode = this.gltfNodeIdToNodeMap.get(targetNodeId);
-      if (!targetNode) {
-        throw new Error(`Cannot find animation target node ${targetNodeId}`);
+    this.animation.channels.forEach((channel) => {
+      if (channel.type === "node") {
+        const { sampler, targetNodeId, path } = channel;
+        const targetNode = this.gltfNodeIdToNodeMap.get(targetNodeId);
+        if (!targetNode) {
+          throw new Error(`Cannot find animation target node ${targetNodeId}`);
+        }
+        interpolate(time, sampler, targetNode, path);
+        return;
+      }
+      const material = this.materials[channel.targetMaterialIndex];
+      if (!material) {
+        throw new Error(`Cannot find animation target material ${channel.targetMaterialIndex} for ${channel.pointer}`);
+      }
+      const value = evaluateSampler(time, channel.sampler);
+      if (value) {
+        if (channel.type === "material") {
+          applyMaterialAnimationValue(material, channel, value);
+        } else {
+          applyTextureTransformAnimationValue(material, channel, value, this.materialTextureTransformState);
+        }
       }
-      interpolate(time, sampler, targetNode, path);
     });
   }
 };
@@ -1437,13 +1621,14 @@ var GLTFAnimator = class {
       const name = animation.name || `Animation-${index}`;
       return new GLTFSingleAnimator({
         gltfNodeIdToNodeMap: props.gltfNodeIdToNodeMap,
+        materials: props.materials,
         animation: { name, channels: animation.channels }
       });
     });
   }
   /** @deprecated Use .setTime(). Will be removed (deck.gl is using this) */
   animate(time) {
-    import_core6.log.warn("GLTFAnimator#animate is deprecated. Use GLTFAnimator#setTime instead")();
+    import_core7.log.warn("GLTFAnimator#animate is deprecated. Use GLTFAnimator#setTime instead")();
     this.setTime(time);
   }
   /** Advances every animation to the supplied wall-clock time in milliseconds. */
@@ -1455,114 +1640,71 @@ var GLTFAnimator = class {
     return this.animations;
   }
 };
-
-// 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,
-  VEC2: 2,
-  VEC3: 3,
-  VEC4: 4,
-  MAT2: 4,
-  MAT3: 9,
-  MAT4: 16
-};
-var ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY = {
-  5120: Int8Array,
-  5121: Uint8Array,
-  5122: Int16Array,
-  5123: Uint16Array,
-  5125: Uint32Array,
-  5126: Float32Array
-};
-function accessorToTypedArray(accessor) {
-  var _a;
-  const ArrayType = ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY[accessor.componentType];
-  const components = ATTRIBUTE_TYPE_TO_COMPONENTS[accessor.type];
-  const length = components * accessor.count;
-  const { buffer, byteOffset = 0 } = ((_a = accessor.bufferView) == null ? void 0 : _a.data) ?? {};
-  const typedArray = new ArrayType(buffer, byteOffset + (accessor.byteOffset || 0), length);
-  return { typedArray, components };
+function applyMaterialAnimationValue(material, channel, value) {
+  const pbrMaterial3 = channel.component !== void 0 ? {
+    [channel.property]: updateMaterialArrayComponent(getCurrentMaterialValue(material, channel.property), channel.component, value[0])
+  } : {
+    [channel.property]: value.length === 1 ? value[0] : value
+  };
+  material.setProps({ pbrMaterial: pbrMaterial3 });
 }
-
-// dist/parsers/parse-gltf-animations.js
-function parseGLTFAnimations(gltf) {
-  const gltfAnimations = gltf.animations || [];
-  const accessorCache1D = /* @__PURE__ */ new Map();
-  const accessorCache2D = /* @__PURE__ */ new Map();
-  return gltfAnimations.flatMap((animation, index) => {
-    const name = animation.name || `Animation-${index}`;
-    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}`);
+function getCurrentMaterialValue(material, property) {
+  var _a;
+  const uniformValues = material.shaderInputs.getUniformValues();
+  const currentValue = (_a = uniformValues["pbrMaterial"]) == null ? void 0 : _a[property];
+  return Array.isArray(currentValue) ? [...currentValue] : [];
+}
+function updateMaterialArrayComponent(currentValue, component, nextValue) {
+  const updatedValue = [...currentValue];
+  updatedValue[component] = nextValue;
+  return updatedValue;
+}
+function applyTextureTransformAnimationValue(material, channel, value, materialTextureTransformState) {
+  const slotDefinition = getTextureTransformSlotDefinition(channel.textureSlot);
+  const currentTransform = getCurrentTextureTransform(materialTextureTransformState, material, channel);
+  switch (channel.path) {
+    case "offset":
+      if (channel.component !== void 0) {
+        currentTransform.offset[channel.component] = value[0];
+      } else {
+        currentTransform.offset = [value[0], value[1]];
       }
-      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);
+      break;
+    case "rotation":
+      currentTransform.rotation = value[0];
+      break;
+    case "scale":
+      if (channel.component !== void 0) {
+        currentTransform.scale[channel.component] = value[0];
+      } else {
+        currentTransform.scale = [value[0], value[1]];
       }
-      return {
-        sampler: parsedSampler,
-        targetNodeId: targetNode.id,
-        path
-      };
-    });
-    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);
-  }
-  const { typedArray: array, components } = accessorToTypedArray(accessor);
-  assert(components === 1, "accessorToJsArray1D must have exactly 1 component");
-  const result = Array.from(array);
-  accessorCache.set(accessor, result);
-  return result;
-}
-function accessorToJsArray2D(accessor, accessorCache) {
-  if (accessorCache.has(accessor)) {
-    return accessorCache.get(accessor);
-  }
-  const { typedArray: array, components } = accessorToTypedArray(accessor);
-  assert(components >= 1, "accessorToJsArray2D must have at least 1 component");
-  const result = [];
-  for (let i = 0; i < array.length; i += components) {
-    result.push(Array.from(array.slice(i, i + components)));
+      break;
   }
-  accessorCache.set(accessor, result);
-  return result;
+  material.setProps({
+    pbrMaterial: {
+      [slotDefinition.uvTransformUniform]: getTextureTransformDeltaMatrix(channel.baseTransform, currentTransform)
+    }
+  });
 }
-function assert(condition, message) {
-  if (!condition) {
-    throw new Error(message);
+function getCurrentTextureTransform(materialTextureTransformState, material, channel) {
+  const materialState = materialTextureTransformState.get(material) || {};
+  let textureTransformState = materialState[channel.textureSlot];
+  if (!textureTransformState) {
+    textureTransformState = {
+      offset: [...channel.baseTransform.offset],
+      rotation: channel.baseTransform.rotation,
+      scale: [...channel.baseTransform.scale]
+    };
+    materialState[channel.textureSlot] = textureTransformState;
+    materialTextureTransformState.set(material, materialState);
   }
+  return textureTransformState;
 }
 
+// dist/parsers/parse-gltf-animations.js
+var import_core8 = require("@luma.gl/core");
+
 // dist/gltf/gltf-extension-support.js
 var UNKNOWN_EXTENSION_SUPPORT = {
   supportLevel: "none",
@@ -1658,8 +1800,8 @@ var GLTF_EXTENSION_SUPPORT_REGISTRY = {
     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."
+    supportLevel: "parsed-and-wired",
+    comment: "Selected node TRS, material factor, and KHR_texture_transform offset/rotation/scale pointers are wired to runtime updates; unsupported targets are skipped."
   },
   KHR_materials_diffuse_transmission: {
     supportLevel: "none",
@@ -1702,7 +1844,7 @@ function getGLTFExtensionSupport(gltf) {
       extensionName,
       {
         extensionName,
-        supported: extensionSupportDefinition.supportLevel === "built-in",
+        supported: extensionSupportDefinition.supportLevel === "built-in" || extensionSupportDefinition.supportLevel === "parsed-and-wired",
         supportLevel: extensionSupportDefinition.supportLevel,
         comment: extensionSupportDefinition.comment
       }
@@ -1710,6 +1852,9 @@ function getGLTFExtensionSupport(gltf) {
   });
   return new Map(extensionSupportEntries);
 }
+function getRegisteredGLTFExtensionSupport(extensionName) {
+  return GLTF_EXTENSION_SUPPORT_REGISTRY[extensionName] || null;
+}
 function collectGLTFExtensionNames(gltf) {
   var _a;
   const gltfWithRemovedExtensions = gltf;
@@ -1718,10 +1863,10 @@ function collectGLTFExtensionNames(gltf) {
   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)) {
+  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) => {
+  if ((gltf.materials || []).some((material) => {
     var _a2;
     const gltfMaterial = material;
     return gltfMaterial.unlit || ((_a2 = gltfMaterial.extensions) == null ? void 0 : _a2.KHR_materials_unlit);
@@ -1736,12 +1881,358 @@ function addExtensionNames(extensionNames, newExtensionNames = []) {
   }
 }
 
+// dist/webgl-to-webgpu/convert-webgl-attribute.js
+var ATTRIBUTE_TYPE_TO_COMPONENTS = {
+  SCALAR: 1,
+  VEC2: 2,
+  VEC3: 3,
+  VEC4: 4,
+  MAT2: 4,
+  MAT3: 9,
+  MAT4: 16
+};
+var ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY = {
+  5120: Int8Array,
+  5121: Uint8Array,
+  5122: Int16Array,
+  5123: Uint16Array,
+  5125: Uint32Array,
+  5126: Float32Array
+};
+function accessorToTypedArray(accessor) {
+  var _a;
+  const ArrayType = ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY[accessor.componentType];
+  const components = ATTRIBUTE_TYPE_TO_COMPONENTS[accessor.type];
+  const length = components * accessor.count;
+  const { buffer, byteOffset = 0 } = ((_a = accessor.bufferView) == null ? void 0 : _a.data) ?? {};
+  const typedArray = new ArrayType(buffer, byteOffset + (accessor.byteOffset || 0), length);
+  return { typedArray, components };
+}
+
+// dist/parsers/parse-gltf-animations.js
+function parseGLTFAnimations(gltf) {
+  const gltfAnimations = gltf.animations || [];
+  const accessorCache1D = /* @__PURE__ */ new Map();
+  const accessorCache2D = /* @__PURE__ */ new Map();
+  return gltfAnimations.flatMap((animation, index) => {
+    const name = animation.name || `Animation-${index}`;
+    const samplerCache = /* @__PURE__ */ new Map();
+    const channels = animation.channels.flatMap(({ sampler, target }) => {
+      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);
+      }
+      const parsedChannel = parseAnimationChannel(gltf, target, parsedSampler);
+      return parsedChannel ? [parsedChannel] : [];
+    });
+    return channels.length ? [{ name, channels }] : [];
+  });
+}
+function parseAnimationChannel(gltf, target, sampler) {
+  if (target.path === "pointer") {
+    return parseAnimationPointerChannel(gltf, target, sampler);
+  }
+  const path = getNodeAnimationPath(target.path);
+  if (!path) {
+    return null;
+  }
+  const targetNode = gltf.nodes[target.node ?? 0];
+  if (!targetNode) {
+    throw new Error(`Cannot find animation target ${target.node}`);
+  }
+  return {
+    type: "node",
+    sampler,
+    targetNodeId: targetNode.id,
+    path
+  };
+}
+function parseAnimationPointerChannel(gltf, target, sampler) {
+  var _a, _b;
+  const pointer = (_b = (_a = target.extensions) == null ? void 0 : _a["KHR_animation_pointer"]) == null ? void 0 : _b.pointer;
+  if (typeof pointer !== "string" || !pointer.startsWith("/")) {
+    import_core8.log.warn("KHR_animation_pointer channel is missing a valid JSON pointer and will be skipped")();
+    return null;
+  }
+  const pointerSegments = splitJsonPointer(pointer);
+  switch (pointerSegments[0]) {
+    case "nodes":
+      return parseNodePointerAnimationChannel(gltf, pointerSegments, sampler, pointer);
+    case "materials":
+      return parseMaterialPointerAnimationChannel(gltf, pointerSegments, sampler, pointer);
+    default:
+      warnUnsupportedAnimationPointer(pointer, `top-level target "${pointerSegments[0]}" has no runtime animation mapping`);
+      return null;
+  }
+}
+function parseNodePointerAnimationChannel(gltf, pointerSegments, sampler, pointer) {
+  if (pointerSegments.length !== 3) {
+    warnUnsupportedAnimationPointer(pointer, "node pointers must use /nodes/{index}/{translation|rotation|scale|weights}");
+    return null;
+  }
+  const nodeIndex = Number(pointerSegments[1]);
+  const targetNode = gltf.nodes[nodeIndex];
+  if (!Number.isInteger(nodeIndex) || !targetNode) {
+    import_core8.log.warn(`KHR_animation_pointer target ${pointer} references a missing node and will be skipped`)();
+    return null;
+  }
+  const path = getNodeAnimationPath(pointerSegments[2]);
+  if (!path) {
+    warnUnsupportedAnimationPointer(pointer, `node property "${pointerSegments[2]}" has no runtime animation mapping`);
+    return null;
+  }
+  if (path === "weights") {
+    import_core8.log.warn(`KHR_animation_pointer target ${pointer} will be skipped because morph weights are not implemented in GLTFAnimator`)();
+    return null;
+  }
+  return {
+    type: "node",
+    sampler,
+    targetNodeId: targetNode.id,
+    path
+  };
+}
+function parseMaterialPointerAnimationChannel(gltf, pointerSegments, sampler, pointer) {
+  if (pointerSegments.length < 3) {
+    warnUnsupportedAnimationPointer(pointer, "material pointers must include a material index and target property path");
+    return null;
+  }
+  const materialIndex = Number(pointerSegments[1]);
+  const material = gltf.materials[materialIndex];
+  if (!Number.isInteger(materialIndex) || !material) {
+    import_core8.log.warn(`KHR_animation_pointer target ${pointer} references a missing material and will be skipped`)();
+    return null;
+  }
+  const materialTarget = resolveMaterialAnimationTarget(material, pointerSegments.slice(2));
+  if ("reason" in materialTarget) {
+    warnUnsupportedAnimationPointer(pointer, materialTarget.reason);
+    return null;
+  }
+  return {
+    sampler,
+    pointer,
+    targetMaterialIndex: materialIndex,
+    ...materialTarget
+  };
+}
+function getNodeAnimationPath(path) {
+  switch (path) {
+    case "translation":
+    case "rotation":
+    case "scale":
+    case "weights":
+      return path;
+    default:
+      return null;
+  }
+}
+function resolveMaterialAnimationTarget(material, pointerSegments) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r;
+  const textureTransformTarget = resolveTextureTransformAnimationTarget(material, pointerSegments);
+  if (!("reason" in textureTransformTarget)) {
+    return textureTransformTarget;
+  }
+  if (textureTransformTarget.reason !== "not-a-texture-transform-target") {
+    return textureTransformTarget;
+  }
+  const pointerPath = pointerSegments.join("/");
+  switch (pointerPath) {
+    case "pbrMetallicRoughness/baseColorFactor":
+      return material["pbrMetallicRoughness"] ? { type: "material", property: "baseColorFactor" } : { reason: getUnsupportedMaterialPointerReason(pointerSegments) };
+    case "pbrMetallicRoughness/metallicFactor":
+      return material["pbrMetallicRoughness"] ? { type: "material", property: "metallicRoughnessValues", component: 0 } : { reason: getUnsupportedMaterialPointerReason(pointerSegments) };
+    case "pbrMetallicRoughness/roughnessFactor":
+      return material["pbrMetallicRoughness"] ? { type: "material", property: "metallicRoughnessValues", component: 1 } : { reason: getUnsupportedMaterialPointerReason(pointerSegments) };
+    case "normalTexture/scale":
+      return material["normalTexture"] ? { type: "material", property: "normalScale" } : { reason: getUnsupportedMaterialPointerReason(pointerSegments) };
+    case "occlusionTexture/strength":
+      return material["occlusionTexture"] ? { type: "material", property: "occlusionStrength" } : { reason: getUnsupportedMaterialPointerReason(pointerSegments) };
+    case "emissiveFactor":
+      return { type: "material", property: "emissiveFactor" };
+    case "alphaCutoff":
+      return { type: "material", property: "alphaCutoff" };
+    case "extensions/KHR_materials_specular/specularFactor":
+      return ((_a = material["extensions"]) == null ? void 0 : _a["KHR_materials_specular"]) ? { type: "material", property: "specularIntensityFactor" } : { reason: getUnsupportedMaterialPointerReason(pointerSegments) };
+    case "extensions/KHR_materials_specular/specularColorFactor":
+      return ((_b = material["extensions"]) == null ? void 0 : _b["KHR_materials_specular"]) ? { type: "material", property: "specularColorFactor" } : { reason: getUnsupportedMaterialPointerReason(pointerSegments) };
+    case "extensions/KHR_materials_ior/ior":
+      return ((_c = material["extensions"]) == null ? void 0 : _c["KHR_materials_ior"]) ? { type: "material", property: "ior" } : { reason: getUnsupportedMaterialPointerReason(pointerSegments) };
+    case "extensions/KHR_materials_transmission/transmissionFactor":
+      return ((_d = material["extensions"]) == null ? void 0 : _d["KHR_materials_transmission"]) ? { type: "material", property: "transmissionFactor" } : { reason: getUnsupportedMaterialPointerReason(pointerSegments) };
+    case "extensions/KHR_materials_volume/thicknessFactor":
+      return ((_e = material["extensions"]) == null ? void 0 : _e["KHR_materials_volume"]) ? { type: "material", property: "thicknessFactor" } : { reason: getUnsupportedMaterialPointerReason(pointerSegments) };
+    case "extensions/KHR_materials_volume/attenuationDistance":
+      return ((_f = material["extensions"]) == null ? void 0 : _f["KHR_materials_volume"]) ? { type: "material", property: "attenuationDistance" } : { reason: getUnsupportedMaterialPointerReason(pointerSegments) };
+    case "extensions/KHR_materials_volume/attenuationColor":
+      return ((_g = material["extensions"]) == null ? void 0 : _g["KHR_materials_volume"]) ? { type: "material", property: "attenuationColor" } : { reason: getUnsupportedMaterialPointerReason(pointerSegments) };
+    case "extensions/KHR_materials_clearcoat/clearcoatFactor":
+      return ((_h = material["extensions"]) == null ? void 0 : _h["KHR_materials_clearcoat"]) ? { type: "material", property: "clearcoatFactor" } : { reason: getUnsupportedMaterialPointerReason(pointerSegments) };
+    case "extensions/KHR_materials_clearcoat/clearcoatRoughnessFactor":
+      return ((_i = material["extensions"]) == null ? void 0 : _i["KHR_materials_clearcoat"]) ? { type: "material", property: "clearcoatRoughnessFactor" } : { reason: getUnsupportedMaterialPointerReason(pointerSegments) };
+    case "extensions/KHR_materials_sheen/sheenColorFactor":
+      return ((_j = material["extensions"]) == null ? void 0 : _j["KHR_materials_sheen"]) ? { type: "material", property: "sheenColorFactor" } : { reason: getUnsupportedMaterialPointerReason(pointerSegments) };
+    case "extensions/KHR_materials_sheen/sheenRoughnessFactor":
+      return ((_k = material["extensions"]) == null ? void 0 : _k["KHR_materials_sheen"]) ? { type: "material", property: "sheenRoughnessFactor" } : { reason: getUnsupportedMaterialPointerReason(pointerSegments) };
+    case "extensions/KHR_materials_iridescence/iridescenceFactor":
+      return ((_l = material["extensions"]) == null ? void 0 : _l["KHR_materials_iridescence"]) ? { type: "material", property: "iridescenceFactor" } : { reason: getUnsupportedMaterialPointerReason(pointerSegments) };
+    case "extensions/KHR_materials_iridescence/iridescenceIor":
+      return ((_m = material["extensions"]) == null ? void 0 : _m["KHR_materials_iridescence"]) ? { type: "material", property: "iridescenceIor" } : { reason: getUnsupportedMaterialPointerReason(pointerSegments) };
+    case "extensions/KHR_materials_iridescence/iridescenceThicknessMinimum":
+      return ((_n = material["extensions"]) == null ? void 0 : _n["KHR_materials_iridescence"]) ? { type: "material", property: "iridescenceThicknessRange", component: 0 } : { reason: getUnsupportedMaterialPointerReason(pointerSegments) };
+    case "extensions/KHR_materials_iridescence/iridescenceThicknessMaximum":
+      return ((_o = material["extensions"]) == null ? void 0 : _o["KHR_materials_iridescence"]) ? { type: "material", property: "iridescenceThicknessRange", component: 1 } : { reason: getUnsupportedMaterialPointerReason(pointerSegments) };
+    case "extensions/KHR_materials_anisotropy/anisotropyStrength":
+      return ((_p = material["extensions"]) == null ? void 0 : _p["KHR_materials_anisotropy"]) ? { type: "material", property: "anisotropyStrength" } : { reason: getUnsupportedMaterialPointerReason(pointerSegments) };
+    case "extensions/KHR_materials_anisotropy/anisotropyRotation":
+      return ((_q = material["extensions"]) == null ? void 0 : _q["KHR_materials_anisotropy"]) ? { type: "material", property: "anisotropyRotation" } : { reason: getUnsupportedMaterialPointerReason(pointerSegments) };
+    case "extensions/KHR_materials_emissive_strength/emissiveStrength":
+      return ((_r = material["extensions"]) == null ? void 0 : _r["KHR_materials_emissive_strength"]) ? { type: "material", property: "emissiveStrength" } : { reason: getUnsupportedMaterialPointerReason(pointerSegments) };
+    default:
+      return { reason: getUnsupportedMaterialPointerReason(pointerSegments) };
+  }
+}
+function resolveTextureTransformAnimationTarget(material, pointerSegments) {
+  const extensionIndex = pointerSegments.lastIndexOf("extensions");
+  if (extensionIndex < 0 || pointerSegments[extensionIndex + 1] !== "KHR_texture_transform" || extensionIndex < 1) {
+    return { reason: "not-a-texture-transform-target" };
+  }
+  const textureSlotDefinition = resolveTextureTransformSlot(pointerSegments.slice(0, extensionIndex));
+  if (!textureSlotDefinition) {
+    return {
+      reason: getUnsupportedTextureTransformSlotReason(pointerSegments.slice(0, extensionIndex))
+    };
+  }
+  const textureInfo = getNestedMaterialValue(material, textureSlotDefinition.pathSegments);
+  if (!textureInfo) {
+    return {
+      reason: `texture-transform target "${pointerSegments.slice(0, extensionIndex).join("/")}" does not exist on the referenced material`
+    };
+  }
+  const textureTransformPath = pointerSegments[extensionIndex + 2];
+  if (textureTransformPath === "texCoord") {
+    return {
+      reason: "animated KHR_texture_transform.texCoord is unsupported because texCoord selection is structural, not a runtime float/vector update"
+    };
+  }
+  if (textureTransformPath !== "offset" && textureTransformPath !== "rotation" && textureTransformPath !== "scale") {
+    return {
+      reason: `KHR_texture_transform property "${textureTransformPath}" is not animatable; supported properties are offset, rotation, and scale`
+    };
+  }
+  const componentSegment = pointerSegments[extensionIndex + 3];
+  if (pointerSegments.length > extensionIndex + 4) {
+    return {
+      reason: `KHR_texture_transform.${textureTransformPath} does not support nested property paths`
+    };
+  }
+  let component;
+  if (componentSegment !== void 0) {
+    component = Number(componentSegment);
+    if (textureTransformPath === "rotation") {
+      return {
+        reason: "KHR_texture_transform.rotation does not support component indices"
+      };
+    }
+    if (!Number.isInteger(component) || component < 0 || component > 1) {
+      return {
+        reason: `KHR_texture_transform.${textureTransformPath} component index "${componentSegment}" is invalid; only 0 and 1 are supported`
+      };
+    }
+  }
+  return {
+    type: "textureTransform",
+    textureSlot: textureSlotDefinition.slot,
+    path: textureTransformPath,
+    component,
+    baseTransform: resolveTextureTransform(textureInfo)
+  };
+}
+function getNestedMaterialValue(material, pathSegments) {
+  let value = material;
+  for (const pathSegment of pathSegments) {
+    value = value == null ? void 0 : value[pathSegment];
+    if (!value) {
+      return null;
+    }
+  }
+  return value;
+}
+function splitJsonPointer(pointer) {
+  return pointer.slice(1).split("/").map((segment) => segment.replace(/~1/g, "/").replace(/~0/g, "~"));
+}
+function getUnsupportedMaterialPointerReason(pointerSegments) {
+  const extensionName = getPointerExtensionName(pointerSegments);
+  if (extensionName) {
+    const extensionSupport = getRegisteredGLTFExtensionSupport(extensionName);
+    if ((extensionSupport == null ? void 0 : extensionSupport.supportLevel) === "none") {
+      return `${extensionName} is referenced by this pointer, but ${extensionSupport.comment.charAt(0).toLowerCase()}${extensionSupport.comment.slice(1)}`;
+    }
+  }
+  return `no runtime target exists for material property "${pointerSegments.join("/")}"`;
+}
+function getUnsupportedTextureTransformSlotReason(pointerSegments) {
+  const extensionName = getPointerExtensionName(pointerSegments);
+  if (extensionName) {
+    const extensionSupport = getRegisteredGLTFExtensionSupport(extensionName);
+    if ((extensionSupport == null ? void 0 : extensionSupport.supportLevel) === "none") {
+      return `${extensionName} is referenced by this pointer, but ${extensionSupport.comment.charAt(0).toLowerCase()}${extensionSupport.comment.slice(1)}`;
+    }
+  }
+  return `texture-transform target "${pointerSegments.join("/")}" has no runtime texture-slot mapping`;
+}
+function getPointerExtensionName(pointerSegments) {
+  const extensionIndex = pointerSegments.indexOf("extensions");
+  const extensionName = pointerSegments[extensionIndex + 1];
+  return extensionIndex >= 0 && extensionName ? extensionName : null;
+}
+function warnUnsupportedAnimationPointer(pointer, reason) {
+  import_core8.log.warn(`KHR_animation_pointer target ${pointer} will be skipped because ${reason}`)();
+}
+function accessorToJsArray1D(accessor, accessorCache) {
+  if (accessorCache.has(accessor)) {
+    return accessorCache.get(accessor);
+  }
+  const { typedArray: array, components } = accessorToTypedArray(accessor);
+  assert(components === 1, "accessorToJsArray1D must have exactly 1 component");
+  const result = Array.from(array);
+  accessorCache.set(accessor, result);
+  return result;
+}
+function accessorToJsArray2D(accessor, accessorCache) {
+  if (accessorCache.has(accessor)) {
+    return accessorCache.get(accessor);
+  }
+  const { typedArray: array, components } = accessorToTypedArray(accessor);
+  assert(components >= 1, "accessorToJsArray2D must have at least 1 component");
+  const result = [];
+  for (let i = 0; i < array.length; i += components) {
+    result.push(Array.from(array.slice(i, i + components)));
+  }
+  accessorCache.set(accessor, result);
+  return result;
+}
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message);
+  }
+}
+
 // dist/gltf/create-scenegraph-from-gltf.js
 function createScenegraphsFromGLTF(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 animator = new GLTFAnimator({ animations, gltfNodeIdToNodeMap, materials });
+  const lights = parseGLTFLights(gltf, { useByteColors: (options == null ? void 0 : options.useByteColors) ?? true });
   const extensionSupport = getGLTFExtensionSupport(gltf);
   const sceneBounds = scenes.map((scene) => getScenegraphBounds(scene.getBounds()));
   const modelBounds = getCombinedScenegraphBounds(sceneBounds);