@deck.gl/geo-layers 9.3.0-alpha.5 → 9.3.0-alpha.6

package/dist/dist.dev.js

@@ -10208,7 +10208,7 @@ var __exports__ = (() => {
   }
 
   // ../../node_modules/@loaders.gl/xml/dist/xml-loader.js
-  var VERSION = true ? "4.4.0-alpha.18" : "latest";
+  var VERSION = true ? "4.4.1" : "latest";
   var XMLLoader = {
     dataType: null,
     batchType: null,
@@ -10791,7 +10791,7 @@ var __exports__ = (() => {
   var dist_default = new ProbeLog({ id: "@probe.gl/log" });
 
   // ../../node_modules/@loaders.gl/loader-utils/dist/lib/log-utils/log.js
-  var VERSION3 = true ? "4.4.0-alpha.18" : "latest";
+  var VERSION3 = true ? "4.4.1" : "latest";
   var version = VERSION3[0] >= "0" && VERSION3[0] <= "9" ? `v${VERSION3}` : "";
   function createLog() {
     const log8 = new ProbeLog({ id: "loaders.gl" });
@@ -10846,7 +10846,7 @@ var __exports__ = (() => {
         globalThis._loadersgl_.version = NPM_TAG;
         warningIssued = true;
       } else {
-        globalThis._loadersgl_.version = "4.4.0-alpha.18";
+        globalThis._loadersgl_.version = "4.4.1";
       }
     }
     return globalThis._loadersgl_.version;
@@ -11616,7 +11616,7 @@ var __exports__ = (() => {
       }
       this.data = data;
       this.url = typeof data === "string" ? resolvePath(data) : "";
-      this.loadOptions = { ...this.options.core?.loadOptions };
+      this.loadOptions = normalizeDirectLoaderOptions(this.options.core?.loadOptions);
       this.fetch = getFetchFunction(this.loadOptions);
     }
     setProps(options) {
@@ -11659,6 +11659,23 @@ var __exports__ = (() => {
     }
     return (url) => fetch(url);
   }
+  function normalizeDirectLoaderOptions(options) {
+    const loadOptions = { ...options };
+    if (options?.core) {
+      loadOptions.core = { ...options.core };
+    }
+    const topLevelBaseUri = typeof loadOptions.baseUri === "string" ? loadOptions.baseUri : void 0;
+    const topLevelBaseUrl = typeof loadOptions.baseUrl === "string" ? loadOptions.baseUrl : void 0;
+    if (topLevelBaseUri !== void 0 || topLevelBaseUrl !== void 0) {
+      loadOptions.core ||= {};
+      if (loadOptions.core.baseUrl === void 0) {
+        loadOptions.core.baseUrl = topLevelBaseUrl ?? topLevelBaseUri;
+      }
+      delete loadOptions.baseUri;
+      delete loadOptions.baseUrl;
+    }
+    return loadOptions;
+  }
 
   // ../../node_modules/@loaders.gl/loader-utils/dist/lib/sources/image-source.js
   var ImageSource = class {
@@ -11675,7 +11692,7 @@ var __exports__ = (() => {
   }
 
   // ../../node_modules/@loaders.gl/wms/dist/wms-error-loader.js
-  var VERSION5 = true ? "4.4.0-alpha.18" : "latest";
+  var VERSION5 = true ? "4.4.1" : "latest";
   var WMSErrorLoader = {
     dataType: null,
     batchType: null,
@@ -11954,7 +11971,7 @@ var __exports__ = (() => {
   }
 
   // ../../node_modules/@loaders.gl/wms/dist/wms-capabilities-loader.js
-  var VERSION6 = true ? "4.4.0-alpha.18" : "latest";
+  var VERSION6 = true ? "4.4.1" : "latest";
   var WMSCapabilitiesLoader = {
     dataType: null,
     batchType: null,
@@ -12027,7 +12044,7 @@ var __exports__ = (() => {
   };
 
   // ../../node_modules/@loaders.gl/images/dist/lib/utils/version.js
-  var VERSION7 = true ? "4.4.0-alpha.18" : "latest";
+  var VERSION7 = true ? "4.4.1" : "latest";
 
   // ../../node_modules/@loaders.gl/images/dist/lib/category-api/image-type.js
   var parseImageNode = globalThis.loaders?.parseImageNode;
@@ -14482,7 +14499,9 @@ var __exports__ = (() => {
     tileSize = TILE_SIZE4,
     modelMatrix,
     modelMatrixInverse,
-    zoomOffset = 0
+    zoomOffset = 0,
+    visibleMinZoom,
+    visibleMaxZoom
   }) {
     let z = viewport.isGeospatial ? Math.round(viewport.zoom + Math.log2(TILE_SIZE4 / tileSize)) + zoomOffset : Math.ceil(viewport.zoom) + zoomOffset;
     if (typeof minZoom === "number" && Number.isFinite(minZoom) && z < minZoom) {
@@ -14494,6 +14513,12 @@ var __exports__ = (() => {
     if (typeof maxZoom === "number" && Number.isFinite(maxZoom) && z > maxZoom) {
       z = maxZoom;
     }
+    if (visibleMinZoom != null && viewport.zoom < visibleMinZoom) {
+      return [];
+    }
+    if (visibleMaxZoom != null && viewport.zoom > visibleMaxZoom) {
+      return [];
+    }
     let transformedExtent = extent;
     if (modelMatrix && modelMatrixInverse && extent && !viewport.isGeospatial) {
       transformedExtent = transformBox(extent, modelMatrix);
@@ -14572,6 +14597,8 @@ var __exports__ = (() => {
     maxRequests: 6,
     debounceTime: 0,
     zoomOffset: 0,
+    visibleMinZoom: null,
+    visibleMaxZoom: null,
     // onTileLoad: (tile: Tile2DHeader) => void,  // onTileUnload: (tile: Tile2DHeader) => void,  // onTileError: (error: any, tile: Tile2DHeader) => void,  /** Called when all tiles in the current viewport are loaded. */
     // onViewportLoad: ((tiles: Tile2DHeader<DataT>[]) => void) | null,
     onTileLoad: () => {
@@ -14635,6 +14662,7 @@ var __exports__ = (() => {
       if (Number.isFinite(opts.minZoom)) {
         this._minZoom = Math.ceil(opts.minZoom);
       }
+      this._viewport = null;
     }
     // Clean up any outstanding tile requests.
     finalize() {
@@ -14744,7 +14772,7 @@ var __exports__ = (() => {
       modelMatrix,
       modelMatrixInverse
     }) {
-      const { tileSize, extent, zoomOffset } = this.opts;
+      const { tileSize, extent, zoomOffset, visibleMinZoom, visibleMaxZoom } = this.opts;
       return getTileIndices({
         viewport,
         maxZoom,
@@ -14754,7 +14782,9 @@ var __exports__ = (() => {
         extent,
         modelMatrix,
         modelMatrixInverse,
-        zoomOffset
+        zoomOffset,
+        visibleMinZoom,
+        visibleMaxZoom
       });
     }
     /** Returns unique string key for a tile index */
@@ -14981,7 +15011,9 @@ var __exports__ = (() => {
     zRange: null,
     maxRequests: 6,
     debounceTime: 0,
-    zoomOffset: 0
+    zoomOffset: 0,
+    visibleMinZoom: null,
+    visibleMaxZoom: null
   };
   var TileLayer = class extends import_core16.CompositeLayer {
     initializeState() {
@@ -15038,7 +15070,9 @@ var __exports__ = (() => {
         minZoom,
         maxRequests,
         debounceTime,
-        zoomOffset
+        zoomOffset,
+        visibleMinZoom,
+        visibleMaxZoom
       } = this.props;
       return {
         maxCacheSize,
@@ -15051,6 +15085,8 @@ var __exports__ = (() => {
         maxRequests,
         debounceTime,
         zoomOffset,
+        visibleMinZoom,
+        visibleMaxZoom,
         getTileData: this.getTileData.bind(this),
         onTileLoad: this._onTileLoad.bind(this),
         onTileError: this._onTileError.bind(this),
@@ -15126,6 +15162,15 @@ var __exports__ = (() => {
       info.sourceTileSubLayer.updateAutoHighlight(info);
     }
     renderLayers() {
+      const { visibleMinZoom, visibleMaxZoom, minZoom, extent } = this.props;
+      const zoom = this.context.viewport.zoom;
+      const hidden = visibleMinZoom != null && zoom < visibleMinZoom || visibleMaxZoom != null && zoom > visibleMaxZoom || minZoom != null && !extent && zoom < minZoom;
+      if (hidden) {
+        for (const tile of this.state.tileset.tiles) {
+          tile.layers = null;
+        }
+        return [];
+      }
       return this.state.tileset.tiles.map((tile) => {
         const subLayerProps = this.getSubLayerPropsByTile(tile);
         if (!tile.isLoaded && !tile.content) {
@@ -15513,12 +15558,12 @@ out float vTime;
 
   // src/tile-3d-layer/tile-3d-layer.ts
   var import_engine2 = __toESM(require_engine(), 1);
-  var import_core46 = __toESM(require_core(), 1);
+  var import_core47 = __toESM(require_core(), 1);
   var import_layers8 = __toESM(require_layers(), 1);
   var import_mesh_layers2 = __toESM(require_mesh_layers(), 1);
 
   // ../../node_modules/@loaders.gl/textures/dist/lib/utils/version.js
-  var VERSION8 = true ? "4.4.0-alpha.18" : "latest";
+  var VERSION8 = true ? "4.4.1" : "latest";
 
   // ../../node_modules/@loaders.gl/textures/dist/lib/parsers/basis-module-loader.js
   var BASIS_EXTERNAL_LIBRARIES = {
@@ -15637,7 +15682,7 @@ out float vTime;
       "bc7-rgba-unorm",
       "bc7-rgba-unorm-srgb"
     ],
-    WEBGL_compressed_texture_etc1: ["etc1-rbg-unorm-webgl"],
+    WEBGL_compressed_texture_etc1: ["etc1-rgb-unorm-webgl"],
     WEBGL_compressed_texture_etc: [
       "etc2-rgb8unorm",
       "etc2-rgb8unorm-srgb",
@@ -15653,7 +15698,7 @@ out float vTime;
     WEBGL_compressed_texture_pvrtc: [
       "pvrtc-rgb4unorm-webgl",
       "pvrtc-rgba4unorm-webgl",
-      "pvrtc-rbg2unorm-webgl",
+      "pvrtc-rgb2unorm-webgl",
       "pvrtc-rgba2unorm-webgl"
     ],
     WEBGL_compressed_texture_atc: [
@@ -15753,12 +15798,13 @@ out float vTime;
   }
 
   // ../../node_modules/@loaders.gl/textures/dist/lib/parsers/parse-basis.js
+  var basisTranscodingLock = Promise.resolve();
   var BASIS_FORMAT_TO_OUTPUT_OPTIONS = {
     etc1: {
       basisFormat: 0,
       compressed: true,
       format: GL_COMPRESSED_RGB_ETC1_WEBGL,
-      textureFormat: "etc1-rbg-unorm-webgl"
+      textureFormat: "etc1-rgb-unorm-webgl"
     },
     etc2: {
       basisFormat: 1,
@@ -15858,31 +15904,46 @@ out float vTime;
     }
   };
   var BASIS_FORMATS = Object.freeze(Object.keys(BASIS_FORMAT_TO_OUTPUT_OPTIONS));
+  async function withBasisTranscodingLock(transcode) {
+    const previousLock = basisTranscodingLock;
+    let releaseLock;
+    basisTranscodingLock = new Promise((resolve2) => {
+      releaseLock = resolve2;
+    });
+    await previousLock;
+    try {
+      return await transcode();
+    } finally {
+      releaseLock();
+    }
+  }
   async function parseBasis(data, options = {}) {
     const loadLibraryOptions = extractLoadLibraryOptions(options);
-    if (!options.basis?.containerFormat || options.basis.containerFormat === "auto") {
-      if (isKTX(data)) {
-        const fileConstructors = await loadBasisEncoderModule(loadLibraryOptions);
-        return parseKTX2File(fileConstructors.KTX2File, data, options);
-      }
-      const { BasisFile } = await loadBasisTranscoderModule(loadLibraryOptions);
-      return parseBasisFile(BasisFile, data, options);
-    }
-    switch (options.basis.module) {
-      case "encoder":
-        const fileConstructors = await loadBasisEncoderModule(loadLibraryOptions);
-        switch (options.basis.containerFormat) {
-          case "ktx2":
-            return parseKTX2File(fileConstructors.KTX2File, data, options);
-          case "basis":
-          default:
-            return parseBasisFile(fileConstructors.BasisFile, data, options);
+    return await withBasisTranscodingLock(async () => {
+      if (!options.basis?.containerFormat || options.basis.containerFormat === "auto") {
+        if (isKTX(data)) {
+          const fileConstructors = await loadBasisEncoderModule(loadLibraryOptions);
+          return parseKTX2File(fileConstructors.KTX2File, data, options);
         }
-      case "transcoder":
-      default:
         const { BasisFile } = await loadBasisTranscoderModule(loadLibraryOptions);
         return parseBasisFile(BasisFile, data, options);
-    }
+      }
+      switch (options.basis.module) {
+        case "encoder":
+          const fileConstructors = await loadBasisEncoderModule(loadLibraryOptions);
+          switch (options.basis.containerFormat) {
+            case "ktx2":
+              return parseKTX2File(fileConstructors.KTX2File, data, options);
+            case "basis":
+            default:
+              return parseBasisFile(fileConstructors.BasisFile, data, options);
+          }
+        case "transcoder":
+        default:
+          const { BasisFile } = await loadBasisTranscoderModule(loadLibraryOptions);
+          return parseBasisFile(BasisFile, data, options);
+      }
+    });
   }
   function parseBasisFile(BasisFile, data, options) {
     const basisFile = new BasisFile(new Uint8Array(data));
@@ -16022,7 +16083,7 @@ out float vTime;
     } else if (hasSupportedTextureFormat(textureFormats2, [
       "pvrtc-rgb4unorm-webgl",
       "pvrtc-rgba4unorm-webgl",
-      "pvrtc-rbg2unorm-webgl",
+      "pvrtc-rgb2unorm-webgl",
       "pvrtc-rgba2unorm-webgl"
     ])) {
       return {
@@ -16042,7 +16103,7 @@ out float vTime;
       "eac-rg11snorm"
     ])) {
       return "etc2";
-    } else if (textureFormats2.has("etc1-rbg-unorm-webgl")) {
+    } else if (textureFormats2.has("etc1-rgb-unorm-webgl")) {
       return "etc1";
     } else if (hasSupportedTextureFormat(textureFormats2, [
       "atc-rgb-unorm-webgl",
@@ -16087,7 +16148,7 @@ out float vTime;
   };
 
   // ../../node_modules/@luma.gl/gltf/dist/parsers/parse-pbr-material.js
-  var import_core20 = __toESM(require_core3(), 1);
+  var import_core21 = __toESM(require_core3(), 1);
 
   // ../../node_modules/@luma.gl/gltf/dist/webgl-to-webgpu/gltf-webgl-constants.js
   var GLEnum;
@@ -16168,6 +16229,75 @@ out float vTime;
     }
   }
 
+  // ../../node_modules/@luma.gl/gltf/dist/pbr/texture-transform.js
+  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) {
+    const extensionTextureTransform = textureInfo?.["extensions"]?.["KHR_texture_transform"];
+    return {
+      offset: extensionTextureTransform?.offset ? [extensionTextureTransform.offset[0], extensionTextureTransform.offset[1]] : [0, 0],
+      rotation: extensionTextureTransform?.rotation ?? 0,
+      scale: extensionTextureTransform?.scale ? [extensionTextureTransform.scale[0], extensionTextureTransform.scale[1]] : [1, 1]
+    };
+  }
+  function resolveTextureCoordinateSet(textureInfo) {
+    const extensionTextureTransform = textureInfo?.["extensions"]?.["KHR_texture_transform"];
+    return extensionTextureTransform?.["texCoord"] ?? textureInfo?.["texCoord"] ?? 0;
+  }
+  function getTextureTransformMatrix(transform2) {
+    const translationMatrix = new Matrix3().set(1, 0, 0, 0, 1, 0, transform2.offset[0], transform2.offset[1], 1);
+    const rotationMatrix = new Matrix3().set(Math.cos(transform2.rotation), Math.sin(transform2.rotation), 0, -Math.sin(transform2.rotation), Math.cos(transform2.rotation), 0, 0, 0, 1);
+    const scaleMatrix = new Matrix3().set(transform2.scale[0], 0, 0, 0, transform2.scale[1], 0, 0, 0, 1);
+    return Array.from(translationMatrix.multiplyRight(rotationMatrix).multiplyRight(scaleMatrix));
+  }
+
   // ../../node_modules/@luma.gl/gltf/dist/parsers/parse-pbr-material.js
   function parsePBRMaterial(device, material, attributes, options) {
     const parsedMaterial = {
@@ -16208,6 +16338,8 @@ out float vTime;
       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"])
@@ -16220,72 +16352,53 @@ out float vTime;
       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) {
-    const uvDependentTextureSlots = getUvDependentTextureSlots(material);
+    const uvDependentTextureSlots = getUvDependentTextureSlots(material, 0);
     if (uvDependentTextureSlots.length > 0 && !attributes["TEXCOORD_0"]) {
-      import_core20.log.warn(`glTF material uses ${uvDependentTextureSlots.join(", ")} but primitive is missing TEXCOORD_0; textured shading will sample the default UV coordinates`)();
+      import_core21.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_core21.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 || material.extensions?.KHR_materials_unlit);
     if (isUnlitMaterial || attributes["NORMAL"]) {
       return;
     }
     const missingNormalReason = material.normalTexture ? "lit PBR shading with normalTexture" : "lit PBR shading";
-    import_core20.log.warn(`glTF primitive is missing NORMAL while using ${missingNormalReason}; shading will fall back to geometric normals`)();
+    import_core21.log.warn(`glTF primitive is missing NORMAL while using ${missingNormalReason}; shading will fall back to geometric normals`)();
   }
-  function getUvDependentTextureSlots(material) {
+  function getUvDependentTextureSlots(material, textureCoordinateSet) {
     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");
+    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?.[pathSegment];
+      if (!value) {
+        return null;
+      }
+    }
+    return value;
+  }
+  function parseMaterial(device, material, parsedMaterial, attributes, gltf) {
     parsedMaterial.uniforms.unlit = Boolean(material.unlit || material.extensions?.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, {
@@ -16293,7 +16406,9 @@ out float vTime;
           define: "HAS_NORMALMAP",
           enabledUniformName: "normalMapEnabled"
         },
-        gltf
+        gltf,
+        attributes,
+        textureTransformSlot: "normal"
       });
       const { scale: scale12 = 1 } = material.normalTexture;
       parsedMaterial.uniforms.normalScale = scale12;
@@ -16304,7 +16419,9 @@ out float vTime;
           define: "HAS_OCCLUSIONMAP",
           enabledUniformName: "occlusionMapEnabled"
         },
-        gltf
+        gltf,
+        attributes,
+        textureTransformSlot: "occlusion"
       });
       const { strength = 1 } = material.occlusionTexture;
       parsedMaterial.uniforms.occlusionStrength = strength;
@@ -16316,10 +16433,12 @@ out float vTime;
           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;
@@ -16331,7 +16450,7 @@ out float vTime;
         break;
       }
       case "BLEND":
-        import_core20.log.warn("glTF BLEND alphaMode might not work well because it requires mesh sorting")();
+        import_core21.log.warn("glTF BLEND alphaMode might not work well because it requires mesh sorting")();
         applyAlphaBlendParameters(parsedMaterial);
         break;
     }
@@ -16372,14 +16491,16 @@ out float vTime;
       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];
@@ -16389,33 +16510,35 @@ out float vTime;
           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;
     }
@@ -16431,7 +16554,9 @@ out float vTime;
           define: "HAS_SPECULARCOLORMAP",
           enabledUniformName: "specularColorMapEnabled"
         },
-        gltf
+        gltf,
+        attributes,
+        textureTransformSlot: "specularColor"
       });
     }
     if (extension.specularTexture) {
@@ -16440,7 +16565,9 @@ out float vTime;
           define: "HAS_SPECULARINTENSITYMAP",
           enabledUniformName: "specularIntensityMapEnabled"
         },
-        gltf
+        gltf,
+        attributes,
+        textureTransformSlot: "specularIntensity"
       });
     }
   }
@@ -16449,7 +16576,7 @@ out float vTime;
       parsedMaterial.uniforms.ior = extension.ior;
     }
   }
-  function parseTransmissionExtension(device, extension, parsedMaterial, gltf) {
+  function parseTransmissionExtension(device, extension, parsedMaterial, gltf, attributes = {}) {
     if (!extension) {
       return;
     }
@@ -16462,15 +16589,17 @@ out float vTime;
           define: "HAS_TRANSMISSIONMAP",
           enabledUniformName: "transmissionMapEnabled"
         },
-        gltf
+        gltf,
+        attributes,
+        textureTransformSlot: "transmission"
       });
     }
     if ((extension.transmissionFactor ?? 0) > 0 || extension.transmissionTexture) {
-      import_core20.log.warn("KHR_materials_transmission uses a premultiplied-alpha blending approximation and may require mesh sorting")();
+      import_core21.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;
     }
@@ -16482,7 +16611,9 @@ out float vTime;
         featureOptions: {
           define: "HAS_THICKNESSMAP"
         },
-        gltf
+        gltf,
+        attributes,
+        textureTransformSlot: "thickness"
       });
     }
     if (extension.attenuationDistance !== void 0) {
@@ -16492,7 +16623,7 @@ out float vTime;
       parsedMaterial.uniforms.attenuationColor = extension.attenuationColor;
     }
   }
-  function parseClearcoatExtension(device, extension, parsedMaterial, gltf) {
+  function parseClearcoatExtension(device, extension, parsedMaterial, gltf, attributes = {}) {
     if (!extension) {
       return;
     }
@@ -16508,7 +16639,9 @@ out float vTime;
           define: "HAS_CLEARCOATMAP",
           enabledUniformName: "clearcoatMapEnabled"
         },
-        gltf
+        gltf,
+        attributes,
+        textureTransformSlot: "clearcoat"
       });
     }
     if (extension.clearcoatRoughnessTexture) {
@@ -16517,7 +16650,9 @@ out float vTime;
           define: "HAS_CLEARCOATROUGHNESSMAP",
           enabledUniformName: "clearcoatRoughnessMapEnabled"
         },
-        gltf
+        gltf,
+        attributes,
+        textureTransformSlot: "clearcoatRoughness"
       });
     }
     if (extension.clearcoatNormalTexture) {
@@ -16525,11 +16660,13 @@ out float vTime;
         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;
     }
@@ -16545,7 +16682,9 @@ out float vTime;
           define: "HAS_SHEENCOLORMAP",
           enabledUniformName: "sheenColorMapEnabled"
         },
-        gltf
+        gltf,
+        attributes,
+        textureTransformSlot: "sheenColor"
       });
     }
     if (extension.sheenRoughnessTexture) {
@@ -16554,11 +16693,13 @@ out float vTime;
           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;
     }
@@ -16580,7 +16721,9 @@ out float vTime;
           define: "HAS_IRIDESCENCEMAP",
           enabledUniformName: "iridescenceMapEnabled"
         },
-        gltf
+        gltf,
+        attributes,
+        textureTransformSlot: "iridescence"
       });
     }
     if (extension.iridescenceThicknessTexture) {
@@ -16588,11 +16731,13 @@ out float vTime;
         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;
     }
@@ -16608,7 +16753,9 @@ out float vTime;
           define: "HAS_ANISOTROPYMAP",
           enabledUniformName: "anisotropyMapEnabled"
         },
-        gltf
+        gltf,
+        attributes,
+        textureTransformSlot: "anisotropy"
       });
     }
   }
@@ -16618,12 +16765,21 @@ out float vTime;
     }
   }
   function addTexture(device, gltfTexture, uniformName, parsedMaterial, textureParseOptions = {}) {
-    const { featureOptions = {}, gltf } = textureParseOptions;
+    const { featureOptions = {}, gltf, attributes = {}, textureTransformSlot } = textureParseOptions;
     const { define: define2, enabledUniformName } = featureOptions;
+    const textureCoordinateSet = resolveTextureCoordinateSet(gltfTexture);
+    if (textureCoordinateSet > 1) {
+      import_core21.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_core21.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 = resolvedTextureInfo.texture?.source?.image;
     if (!image) {
-      import_core20.log.warn(`Skipping unresolved glTF texture for ${String(uniformName)}`)();
+      import_core21.log.warn(`Skipping unresolved glTF texture for ${String(uniformName)}`)();
       return;
     }
     const gltfSampler = {
@@ -16659,6 +16815,11 @@ out float vTime;
     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) {
@@ -16697,7 +16858,7 @@ out float vTime;
     return level.textureFormat;
   }
   function getMaxCompressedMipLevels(baseWidth, baseHeight, format) {
-    const { blockWidth = 1, blockHeight = 1 } = import_core20.textureFormatDecoder.getInfo(format);
+    const { blockWidth = 1, blockHeight = 1 } = import_core21.textureFormatDecoder.getInfo(format);
     let count = 1;
     for (let i = 1; ; i++) {
       const w2 = Math.max(1, baseWidth >> i);
@@ -16718,19 +16879,19 @@ out float vTime;
       levels = [];
     }
     if (levels.length === 0 || !levels[0]?.data) {
-      import_core20.log.warn("createCompressedTexture: compressed image has no valid mip levels, creating fallback")();
+      import_core21.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_core20.log.warn("createCompressedTexture: base level has invalid dimensions, creating fallback")();
+      import_core21.log.warn("createCompressedTexture: base level has invalid dimensions, creating fallback")();
       return createCompressedTextureFallback(device, baseOptions);
     }
     const format = resolveCompressedTextureFormat(baseLevel);
     if (!format) {
-      import_core20.log.warn("createCompressedTexture: compressed image has no textureFormat, creating fallback")();
+      import_core21.log.warn("createCompressedTexture: compressed image has no textureFormat, creating fallback")();
       return createCompressedTextureFallback(device, baseOptions);
     }
     const maxMipLevels = getMaxCompressedMipLevels(baseWidth, baseHeight, format);
@@ -16739,18 +16900,18 @@ out float vTime;
     for (let i = 1; i < levelLimit; i++) {
       const level = levels[i];
       if (!level.data || level.width <= 0 || level.height <= 0) {
-        import_core20.log.warn(`createCompressedTexture: mip level ${i} has invalid data/dimensions, truncating`)();
+        import_core21.log.warn(`createCompressedTexture: mip level ${i} has invalid data/dimensions, truncating`)();
         break;
       }
       const levelFormat = resolveCompressedTextureFormat(level);
       if (levelFormat && levelFormat !== format) {
-        import_core20.log.warn(`createCompressedTexture: mip level ${i} format '${levelFormat}' differs from base '${format}', truncating`)();
+        import_core21.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_core20.log.warn(`createCompressedTexture: mip level ${i} dimensions ${level.width}x${level.height} don't match expected ${expectedW}x${expectedH}, truncating`)();
+        import_core21.log.warn(`createCompressedTexture: mip level ${i} dimensions ${level.width}x${level.height} don't match expected ${expectedW}x${expectedH}, truncating`)();
         break;
       }
       validLevelCount++;
@@ -16758,7 +16919,7 @@ out float vTime;
     const texture = device.createTexture({
       ...baseOptions,
       format,
-      usage: import_core20.Texture.TEXTURE | import_core20.Texture.COPY_DST,
+      usage: import_core21.Texture.TEXTURE | import_core21.Texture.COPY_DST,
       width: baseWidth,
       height: baseHeight,
       mipLevels: validLevelCount,
@@ -16774,8 +16935,19 @@ out float vTime;
     return texture;
   }
 
+  // ../../node_modules/@luma.gl/shadertools/dist/lib/color/normalize-byte-colors.js
+  function resolveUseByteColors(useByteColors, defaultUseByteColors = true) {
+    return useByteColors ?? defaultUseByteColors;
+  }
+  function normalizeByteColor3(color = [0, 0, 0], useByteColors = true) {
+    if (!useByteColors) {
+      return [...color];
+    }
+    return color.map((component) => component / 255);
+  }
+
   // ../../node_modules/@luma.gl/shadertools/dist/modules/lighting/lights/lighting.js
-  var import_core21 = __toESM(require_core3(), 1);
+  var import_core22 = __toESM(require_core3(), 1);
 
   // ../../node_modules/@luma.gl/shadertools/dist/modules/lighting/lights/lighting-glsl.js
   var lightingUniformsGLSL = (
@@ -16950,7 +17122,6 @@ fn getSpotLightAttenuation(spotLight: SpotLight, positionWorldspace: vec3<f32>)
 
   // ../../node_modules/@luma.gl/shadertools/dist/modules/lighting/lights/lighting.js
   var MAX_LIGHTS = 5;
-  var COLOR_FACTOR = 255;
   var LIGHT_UNIFORM_TYPE = {
     color: "vec3<f32>",
     position: "vec3<f32>",
@@ -16989,7 +17160,7 @@ fn getSpotLightAttenuation(spotLight: SpotLight, positionWorldspace: vec3<f32>)
     if (props.lights) {
       props = { ...props, ...extractLightTypes(props.lights), lights: void 0 };
     }
-    const { ambientLight, pointLights, spotLights, directionalLights } = props || {};
+    const { useByteColors, ambientLight, pointLights, spotLights, directionalLights } = props || {};
     const hasLights = ambientLight || pointLights && pointLights.length > 0 || spotLights && spotLights.length > 0 || directionalLights && directionalLights.length > 0;
     if (!hasLights) {
       return {
@@ -16999,14 +17170,20 @@ fn getSpotLightAttenuation(spotLight: SpotLight, positionWorldspace: vec3<f32>)
     }
     const uniforms = {
       ...createDefaultLightingUniforms(),
-      ...getLightSourceUniforms({ ambientLight, pointLights, spotLights, directionalLights })
+      ...getLightSourceUniforms({
+        useByteColors,
+        ambientLight,
+        pointLights,
+        spotLights,
+        directionalLights
+      })
     };
     if (props.enabled !== void 0) {
       uniforms.enabled = props.enabled ? 1 : 0;
     }
     return uniforms;
   }
-  function getLightSourceUniforms({ ambientLight, pointLights = [], spotLights = [], directionalLights = [] }) {
+  function getLightSourceUniforms({ useByteColors, ambientLight, pointLights = [], spotLights = [], directionalLights = [] }) {
     const lights = createDefaultLightUniforms();
     let currentLight = 0;
     let pointLightCount = 0;
@@ -17018,7 +17195,7 @@ fn getSpotLightAttenuation(spotLight: SpotLight, positionWorldspace: vec3<f32>)
       }
       lights[currentLight] = {
         ...lights[currentLight],
-        color: convertColor(pointLight),
+        color: convertColor(pointLight, useByteColors),
         position: pointLight.position,
         attenuation: pointLight.attenuation || [1, 0, 0]
       };
@@ -17031,7 +17208,7 @@ fn getSpotLightAttenuation(spotLight: SpotLight, positionWorldspace: vec3<f32>)
       }
       lights[currentLight] = {
         ...lights[currentLight],
-        color: convertColor(spotLight),
+        color: convertColor(spotLight, useByteColors),
         position: spotLight.position,
         direction: spotLight.direction,
         attenuation: spotLight.attenuation || [1, 0, 0],
@@ -17046,17 +17223,17 @@ fn getSpotLightAttenuation(spotLight: SpotLight, positionWorldspace: vec3<f32>)
       }
       lights[currentLight] = {
         ...lights[currentLight],
-        color: convertColor(directionalLight),
+        color: convertColor(directionalLight, useByteColors),
         direction: directionalLight.direction
       };
       currentLight++;
       directionalLightCount++;
     }
     if (pointLights.length + spotLights.length + directionalLights.length > MAX_LIGHTS) {
-      import_core21.log.warn(`MAX_LIGHTS exceeded, truncating to ${MAX_LIGHTS}`)();
+      import_core22.log.warn(`MAX_LIGHTS exceeded, truncating to ${MAX_LIGHTS}`)();
     }
     return {
-      ambientColor: convertColor(ambientLight),
+      ambientColor: convertColor(ambientLight, useByteColors),
       directionalLightCount,
       pointLightCount,
       spotLightCount,
@@ -17084,9 +17261,10 @@ fn getSpotLightAttenuation(spotLight: SpotLight, positionWorldspace: vec3<f32>)
     }
     return lightSources;
   }
-  function convertColor(colorDef = {}) {
+  function convertColor(colorDef = {}, useByteColors) {
     const { color = [0, 0, 0], intensity = 1 } = colorDef;
-    return color.map((component) => component * intensity / COLOR_FACTOR);
+    const normalizedColor = normalizeByteColor3(color, resolveUseByteColors(useByteColors, true));
+    return normalizedColor.map((component) => component * intensity);
   }
   function createDefaultLightingUniforms() {
     return {
@@ -17155,7 +17333,8 @@ uniform sampler2D pbr_brdfLUT;
   var vs = (
     /* glsl */
     `out vec3 pbr_vPosition;
-out vec2 pbr_vUV;
+out vec2 pbr_vUV0;
+out vec2 pbr_vUV1;
 
 #ifdef HAS_NORMALS
 # ifdef HAS_TANGENTS
@@ -17165,7 +17344,13 @@ out vec3 pbr_vNormal;
 # endif
 #endif
 
-void pbr_setPositionNormalTangentUV(vec4 position, vec4 normal, vec4 tangent, vec2 uv)
+void pbr_setPositionNormalTangentUV(
+  vec4 position,
+  vec4 normal,
+  vec4 tangent,
+  vec2 uv0,
+  vec2 uv1
+)
 {
   vec4 pos = pbrProjection.modelMatrix * position;
   pbr_vPosition = vec3(pos.xyz) / pos.w;
@@ -17182,10 +17367,12 @@ void pbr_setPositionNormalTangentUV(vec4 position, vec4 normal, vec4 tangent, ve
 #endif
 
 #ifdef HAS_UV
-  pbr_vUV = uv;
+  pbr_vUV0 = uv0;
 #else
-  pbr_vUV = vec2(0.,0.);
+  pbr_vUV0 = vec2(0.,0.);
 #endif
+
+  pbr_vUV1 = uv1;
 }
 `
   );
@@ -17261,6 +17448,41 @@ layout(std140) uniform pbrMaterialUniforms {
   vec4 scaleDiffBaseMR;
   vec4 scaleFGDSpec;
   // #endif
+
+  int baseColorUVSet;
+  mat3 baseColorUVTransform;
+  int metallicRoughnessUVSet;
+  mat3 metallicRoughnessUVTransform;
+  int normalUVSet;
+  mat3 normalUVTransform;
+  int occlusionUVSet;
+  mat3 occlusionUVTransform;
+  int emissiveUVSet;
+  mat3 emissiveUVTransform;
+  int specularColorUVSet;
+  mat3 specularColorUVTransform;
+  int specularIntensityUVSet;
+  mat3 specularIntensityUVTransform;
+  int transmissionUVSet;
+  mat3 transmissionUVTransform;
+  int thicknessUVSet;
+  mat3 thicknessUVTransform;
+  int clearcoatUVSet;
+  mat3 clearcoatUVTransform;
+  int clearcoatRoughnessUVSet;
+  mat3 clearcoatRoughnessUVTransform;
+  int clearcoatNormalUVSet;
+  mat3 clearcoatNormalUVTransform;
+  int sheenColorUVSet;
+  mat3 sheenColorUVTransform;
+  int sheenRoughnessUVSet;
+  mat3 sheenRoughnessUVTransform;
+  int iridescenceUVSet;
+  mat3 iridescenceUVTransform;
+  int iridescenceThicknessUVSet;
+  mat3 iridescenceThicknessUVTransform;
+  int anisotropyUVSet;
+  mat3 anisotropyUVTransform;
 } pbrMaterial;
 
 // Samplers
@@ -17318,7 +17540,8 @@ uniform sampler2D pbr_anisotropySampler;
 // Inputs from vertex shader
 
 in vec3 pbr_vPosition;
-in vec2 pbr_vUV;
+in vec2 pbr_vUV0;
+in vec2 pbr_vUV1;
 
 #ifdef HAS_NORMALS
 #ifdef HAS_TANGENTS
@@ -17368,14 +17591,20 @@ vec4 SRGBtoLINEAR(vec4 srgbIn)
 #endif //MANUAL_SRGB
 }
 
+vec2 getMaterialUV(int uvSet, mat3 uvTransform)
+{
+  vec2 baseUV = uvSet == 1 ? pbr_vUV1 : pbr_vUV0;
+  return (uvTransform * vec3(baseUV, 1.0)).xy;
+}
+
 // Build the tangent basis from interpolated attributes or screen-space derivatives.
-mat3 getTBN()
+mat3 getTBN(vec2 uv)
 {
 #ifndef HAS_TANGENTS
   vec3 pos_dx = dFdx(pbr_vPosition);
   vec3 pos_dy = dFdy(pbr_vPosition);
-  vec3 tex_dx = dFdx(vec3(pbr_vUV, 0.0));
-  vec3 tex_dy = dFdy(vec3(pbr_vUV, 0.0));
+  vec3 tex_dx = dFdx(vec3(uv, 0.0));
+  vec3 tex_dy = dFdy(vec3(uv, 0.0));
   vec3 t = (tex_dy.t * pos_dx - tex_dx.t * pos_dy) / (tex_dx.s * tex_dy.t - tex_dy.s * tex_dx.t);
 
 #ifdef HAS_NORMALS
@@ -17396,16 +17625,16 @@ mat3 getTBN()
 
 // Find the normal for this fragment, pulling either from a predefined normal map
 // or from the interpolated mesh normal and tangent attributes.
-vec3 getMappedNormal(sampler2D normalSampler, mat3 tbn, float normalScale)
+vec3 getMappedNormal(sampler2D normalSampler, mat3 tbn, float normalScale, vec2 uv)
 {
-  vec3 n = texture(normalSampler, pbr_vUV).rgb;
+  vec3 n = texture(normalSampler, uv).rgb;
   return normalize(tbn * ((2.0 * n - 1.0) * vec3(normalScale, normalScale, 1.0)));
 }
 
-vec3 getNormal(mat3 tbn)
+vec3 getNormal(mat3 tbn, vec2 uv)
 {
 #ifdef HAS_NORMALMAP
-  vec3 n = getMappedNormal(pbr_normalSampler, tbn, pbrMaterial.normalScale);
+  vec3 n = getMappedNormal(pbr_normalSampler, tbn, pbrMaterial.normalScale, uv);
 #else
   // The tbn matrix is linearly interpolated, so we need to re-normalize
   vec3 n = normalize(tbn[2].xyz);
@@ -17414,10 +17643,10 @@ vec3 getNormal(mat3 tbn)
   return n;
 }
 
-vec3 getClearcoatNormal(mat3 tbn, vec3 baseNormal)
+vec3 getClearcoatNormal(mat3 tbn, vec3 baseNormal, vec2 uv)
 {
 #ifdef HAS_CLEARCOATNORMALMAP
-  return getMappedNormal(pbr_clearcoatNormalSampler, tbn, 1.0);
+  return getMappedNormal(pbr_clearcoatNormalSampler, tbn, 1.0, uv);
 #else
   return baseNormal;
 #endif
@@ -17705,9 +17934,61 @@ vec3 calculateFinalColor(PBRInfo pbrInfo, vec3 lightColor) {
 
 vec4 pbr_filterColor(vec4 colorUnused)
 {
+  vec2 baseColorUV = getMaterialUV(pbrMaterial.baseColorUVSet, pbrMaterial.baseColorUVTransform);
+  vec2 metallicRoughnessUV = getMaterialUV(
+    pbrMaterial.metallicRoughnessUVSet,
+    pbrMaterial.metallicRoughnessUVTransform
+  );
+  vec2 normalUV = getMaterialUV(pbrMaterial.normalUVSet, pbrMaterial.normalUVTransform);
+  vec2 occlusionUV = getMaterialUV(pbrMaterial.occlusionUVSet, pbrMaterial.occlusionUVTransform);
+  vec2 emissiveUV = getMaterialUV(pbrMaterial.emissiveUVSet, pbrMaterial.emissiveUVTransform);
+  vec2 specularColorUV = getMaterialUV(
+    pbrMaterial.specularColorUVSet,
+    pbrMaterial.specularColorUVTransform
+  );
+  vec2 specularIntensityUV = getMaterialUV(
+    pbrMaterial.specularIntensityUVSet,
+    pbrMaterial.specularIntensityUVTransform
+  );
+  vec2 transmissionUV = getMaterialUV(
+    pbrMaterial.transmissionUVSet,
+    pbrMaterial.transmissionUVTransform
+  );
+  vec2 thicknessUV = getMaterialUV(pbrMaterial.thicknessUVSet, pbrMaterial.thicknessUVTransform);
+  vec2 clearcoatUV = getMaterialUV(pbrMaterial.clearcoatUVSet, pbrMaterial.clearcoatUVTransform);
+  vec2 clearcoatRoughnessUV = getMaterialUV(
+    pbrMaterial.clearcoatRoughnessUVSet,
+    pbrMaterial.clearcoatRoughnessUVTransform
+  );
+  vec2 clearcoatNormalUV = getMaterialUV(
+    pbrMaterial.clearcoatNormalUVSet,
+    pbrMaterial.clearcoatNormalUVTransform
+  );
+  vec2 sheenColorUV = getMaterialUV(
+    pbrMaterial.sheenColorUVSet,
+    pbrMaterial.sheenColorUVTransform
+  );
+  vec2 sheenRoughnessUV = getMaterialUV(
+    pbrMaterial.sheenRoughnessUVSet,
+    pbrMaterial.sheenRoughnessUVTransform
+  );
+  vec2 iridescenceUV = getMaterialUV(
+    pbrMaterial.iridescenceUVSet,
+    pbrMaterial.iridescenceUVTransform
+  );
+  vec2 iridescenceThicknessUV = getMaterialUV(
+    pbrMaterial.iridescenceThicknessUVSet,
+    pbrMaterial.iridescenceThicknessUVTransform
+  );
+  vec2 anisotropyUV = getMaterialUV(
+    pbrMaterial.anisotropyUVSet,
+    pbrMaterial.anisotropyUVTransform
+  );
+
   // The albedo may be defined from a base texture or a flat color
 #ifdef HAS_BASECOLORMAP
-  vec4 baseColor = SRGBtoLINEAR(texture(pbr_baseColorSampler, pbr_vUV)) * pbrMaterial.baseColorFactor;
+  vec4 baseColor =
+    SRGBtoLINEAR(texture(pbr_baseColorSampler, baseColorUV)) * pbrMaterial.baseColorFactor;
 #else
   vec4 baseColor = pbrMaterial.baseColorFactor;
 #endif
@@ -17734,14 +18015,14 @@ vec4 pbr_filterColor(vec4 colorUnused)
 #ifdef HAS_METALROUGHNESSMAP
     // Roughness is stored in the 'g' channel, metallic is stored in the 'b' channel.
     // This layout intentionally reserves the 'r' channel for (optional) occlusion map data
-    vec4 mrSample = texture(pbr_metallicRoughnessSampler, pbr_vUV);
+    vec4 mrSample = texture(pbr_metallicRoughnessSampler, metallicRoughnessUV);
     perceptualRoughness = mrSample.g * perceptualRoughness;
     metallic = mrSample.b * metallic;
 #endif
     perceptualRoughness = clamp(perceptualRoughness, c_MinRoughness, 1.0);
     metallic = clamp(metallic, 0.0, 1.0);
-    mat3 tbn = getTBN();
-    vec3 n = getNormal(tbn);                          // normal at surface point
+    mat3 tbn = getTBN(normalUV);
+    vec3 n = getNormal(tbn, normalUV);                          // normal at surface point
     vec3 v = normalize(pbrProjection.camera - pbr_vPosition);  // Vector from surface point to camera
     float NdotV = clamp(abs(dot(n, v)), 0.001, 1.0);
 #ifdef USE_MATERIAL_EXTENSIONS
@@ -17842,7 +18123,7 @@ vec4 pbr_filterColor(vec4 colorUnused)
 
 #ifdef HAS_OCCLUSIONMAP
       if (pbrMaterial.occlusionMapEnabled) {
-        float ao = texture(pbr_occlusionSampler, pbr_vUV).r;
+        float ao = texture(pbr_occlusionSampler, occlusionUV).r;
         color = mix(color, color * ao, pbrMaterial.occlusionStrength);
       }
 #endif
@@ -17850,7 +18131,7 @@ vec4 pbr_filterColor(vec4 colorUnused)
       vec3 emissive = pbrMaterial.emissiveFactor;
 #ifdef HAS_EMISSIVEMAP
       if (pbrMaterial.emissiveMapEnabled) {
-        emissive *= SRGBtoLINEAR(texture(pbr_emissiveSampler, pbr_vUV)).rgb;
+        emissive *= SRGBtoLINEAR(texture(pbr_emissiveSampler, emissiveUV)).rgb;
       }
 #endif
       color += emissive * pbrMaterial.emissiveStrength;
@@ -17867,55 +18148,55 @@ vec4 pbr_filterColor(vec4 colorUnused)
     float specularIntensity = pbrMaterial.specularIntensityFactor;
 #ifdef HAS_SPECULARINTENSITYMAP
     if (pbrMaterial.specularIntensityMapEnabled) {
-      specularIntensity *= texture(pbr_specularIntensitySampler, pbr_vUV).a;
+      specularIntensity *= texture(pbr_specularIntensitySampler, specularIntensityUV).a;
     }
 #endif
 
     vec3 specularFactor = pbrMaterial.specularColorFactor;
 #ifdef HAS_SPECULARCOLORMAP
     if (pbrMaterial.specularColorMapEnabled) {
-      specularFactor *= SRGBtoLINEAR(texture(pbr_specularColorSampler, pbr_vUV)).rgb;
+      specularFactor *= SRGBtoLINEAR(texture(pbr_specularColorSampler, specularColorUV)).rgb;
     }
 #endif
 
     transmission = pbrMaterial.transmissionFactor;
 #ifdef HAS_TRANSMISSIONMAP
     if (pbrMaterial.transmissionMapEnabled) {
-      transmission *= texture(pbr_transmissionSampler, pbr_vUV).r;
+      transmission *= texture(pbr_transmissionSampler, transmissionUV).r;
     }
 #endif
     transmission = clamp(transmission * (1.0 - metallic), 0.0, 1.0);
     float thickness = max(pbrMaterial.thicknessFactor, 0.0);
 #ifdef HAS_THICKNESSMAP
-    thickness *= texture(pbr_thicknessSampler, pbr_vUV).g;
+    thickness *= texture(pbr_thicknessSampler, thicknessUV).g;
 #endif
 
     float clearcoatFactor = pbrMaterial.clearcoatFactor;
     float clearcoatRoughness = pbrMaterial.clearcoatRoughnessFactor;
 #ifdef HAS_CLEARCOATMAP
     if (pbrMaterial.clearcoatMapEnabled) {
-      clearcoatFactor *= texture(pbr_clearcoatSampler, pbr_vUV).r;
+      clearcoatFactor *= texture(pbr_clearcoatSampler, clearcoatUV).r;
     }
 #endif
 #ifdef HAS_CLEARCOATROUGHNESSMAP
     if (pbrMaterial.clearcoatRoughnessMapEnabled) {
-      clearcoatRoughness *= texture(pbr_clearcoatRoughnessSampler, pbr_vUV).g;
+      clearcoatRoughness *= texture(pbr_clearcoatRoughnessSampler, clearcoatRoughnessUV).g;
     }
 #endif
     clearcoatFactor = clamp(clearcoatFactor, 0.0, 1.0);
     clearcoatRoughness = clamp(clearcoatRoughness, c_MinRoughness, 1.0);
-    vec3 clearcoatNormal = getClearcoatNormal(tbn, n);
+    vec3 clearcoatNormal = getClearcoatNormal(getTBN(clearcoatNormalUV), n, clearcoatNormalUV);
 
     vec3 sheenColor = pbrMaterial.sheenColorFactor;
     float sheenRoughness = pbrMaterial.sheenRoughnessFactor;
 #ifdef HAS_SHEENCOLORMAP
     if (pbrMaterial.sheenColorMapEnabled) {
-      sheenColor *= SRGBtoLINEAR(texture(pbr_sheenColorSampler, pbr_vUV)).rgb;
+      sheenColor *= SRGBtoLINEAR(texture(pbr_sheenColorSampler, sheenColorUV)).rgb;
     }
 #endif
 #ifdef HAS_SHEENROUGHNESSMAP
     if (pbrMaterial.sheenRoughnessMapEnabled) {
-      sheenRoughness *= texture(pbr_sheenRoughnessSampler, pbr_vUV).a;
+      sheenRoughness *= texture(pbr_sheenRoughnessSampler, sheenRoughnessUV).a;
     }
 #endif
     sheenRoughness = clamp(sheenRoughness, c_MinRoughness, 1.0);
@@ -17923,7 +18204,7 @@ vec4 pbr_filterColor(vec4 colorUnused)
     float iridescence = pbrMaterial.iridescenceFactor;
 #ifdef HAS_IRIDESCENCEMAP
     if (pbrMaterial.iridescenceMapEnabled) {
-      iridescence *= texture(pbr_iridescenceSampler, pbr_vUV).r;
+      iridescence *= texture(pbr_iridescenceSampler, iridescenceUV).r;
     }
 #endif
     iridescence = clamp(iridescence, 0.0, 1.0);
@@ -17936,7 +18217,7 @@ vec4 pbr_filterColor(vec4 colorUnused)
     iridescenceThickness = mix(
       pbrMaterial.iridescenceThicknessRange.x,
       pbrMaterial.iridescenceThicknessRange.y,
-      texture(pbr_iridescenceThicknessSampler, pbr_vUV).g
+      texture(pbr_iridescenceThicknessSampler, iridescenceThicknessUV).g
     );
 #endif
 
@@ -17944,7 +18225,7 @@ vec4 pbr_filterColor(vec4 colorUnused)
     vec2 anisotropyDirection = normalizeDirection(pbrMaterial.anisotropyDirection);
 #ifdef HAS_ANISOTROPYMAP
     if (pbrMaterial.anisotropyMapEnabled) {
-      vec3 anisotropySample = texture(pbr_anisotropySampler, pbr_vUV).rgb;
+      vec3 anisotropySample = texture(pbr_anisotropySampler, anisotropyUV).rgb;
       anisotropyStrength *= anisotropySample.b;
       vec2 mappedDirection = anisotropySample.rg * 2.0 - 1.0;
       if (length(mappedDirection) > 0.0001) {
@@ -18107,7 +18388,7 @@ vec4 pbr_filterColor(vec4 colorUnused)
  // Apply optional PBR terms for additional (optional) shading
 #ifdef HAS_OCCLUSIONMAP
     if (pbrMaterial.occlusionMapEnabled) {
-      float ao = texture(pbr_occlusionSampler, pbr_vUV).r;
+      float ao = texture(pbr_occlusionSampler, occlusionUV).r;
       color = mix(color, color * ao, pbrMaterial.occlusionStrength);
     }
 #endif
@@ -18115,7 +18396,7 @@ vec4 pbr_filterColor(vec4 colorUnused)
     vec3 emissive = pbrMaterial.emissiveFactor;
 #ifdef HAS_EMISSIVEMAP
     if (pbrMaterial.emissiveMapEnabled) {
-      emissive *= SRGBtoLINEAR(texture(pbr_emissiveSampler, pbr_vUV)).rgb;
+      emissive *= SRGBtoLINEAR(texture(pbr_emissiveSampler, emissiveUV)).rgb;
     }
 #endif
     color += emissive * pbrMaterial.emissiveStrength;
@@ -18153,14 +18434,21 @@ vec4 pbr_filterColor(vec4 colorUnused)
     /* wgsl */
     `struct PBRFragmentInputs {
   pbr_vPosition: vec3f,
-  pbr_vUV: vec2f,
+  pbr_vUV0: vec2f,
+  pbr_vUV1: vec2f,
   pbr_vTBN: mat3x3f,
   pbr_vNormal: vec3f
 };
 
 var<private> fragmentInputs: PBRFragmentInputs;
 
-fn pbr_setPositionNormalTangentUV(position: vec4f, normal: vec4f, tangent: vec4f, uv: vec2f)
+fn pbr_setPositionNormalTangentUV(
+  position: vec4f,
+  normal: vec4f,
+  tangent: vec4f,
+  uv0: vec2f,
+  uv1: vec2f
+)
 {
   var pos: vec4f = pbrProjection.modelMatrix * position;
   fragmentInputs.pbr_vPosition = pos.xyz / pos.w;
@@ -18170,7 +18458,8 @@ fn pbr_setPositionNormalTangentUV(position: vec4f, normal: vec4f, tangent: vec4f
     vec3f(0.0, 1.0, 0.0),
     vec3f(0.0, 0.0, 1.0)
   );
-  fragmentInputs.pbr_vUV = vec2f(0.0, 0.0);
+  fragmentInputs.pbr_vUV0 = vec2f(0.0, 0.0);
+  fragmentInputs.pbr_vUV1 = uv1;
 
 #ifdef HAS_NORMALS
   let normalW: vec3f = normalize((pbrProjection.normalMatrix * vec4f(normal.xyz, 0.0)).xyz);
@@ -18183,7 +18472,7 @@ fn pbr_setPositionNormalTangentUV(position: vec4f, normal: vec4f, tangent: vec4f
 #endif
 
 #ifdef HAS_UV
-  fragmentInputs.pbr_vUV = uv;
+  fragmentInputs.pbr_vUV0 = uv0;
 #endif
 }
 
@@ -18255,6 +18544,41 @@ struct pbrMaterialUniforms {
   scaleDiffBaseMR: vec4f,
   scaleFGDSpec: vec4f,
   // #endif
+
+  baseColorUVSet: i32,
+  baseColorUVTransform: mat3x3f,
+  metallicRoughnessUVSet: i32,
+  metallicRoughnessUVTransform: mat3x3f,
+  normalUVSet: i32,
+  normalUVTransform: mat3x3f,
+  occlusionUVSet: i32,
+  occlusionUVTransform: mat3x3f,
+  emissiveUVSet: i32,
+  emissiveUVTransform: mat3x3f,
+  specularColorUVSet: i32,
+  specularColorUVTransform: mat3x3f,
+  specularIntensityUVSet: i32,
+  specularIntensityUVTransform: mat3x3f,
+  transmissionUVSet: i32,
+  transmissionUVTransform: mat3x3f,
+  thicknessUVSet: i32,
+  thicknessUVTransform: mat3x3f,
+  clearcoatUVSet: i32,
+  clearcoatUVTransform: mat3x3f,
+  clearcoatRoughnessUVSet: i32,
+  clearcoatRoughnessUVTransform: mat3x3f,
+  clearcoatNormalUVSet: i32,
+  clearcoatNormalUVTransform: mat3x3f,
+  sheenColorUVSet: i32,
+  sheenColorUVTransform: mat3x3f,
+  sheenRoughnessUVSet: i32,
+  sheenRoughnessUVTransform: mat3x3f,
+  iridescenceUVSet: i32,
+  iridescenceUVTransform: mat3x3f,
+  iridescenceThicknessUVSet: i32,
+  iridescenceThicknessUVTransform: mat3x3f,
+  anisotropyUVSet: i32,
+  anisotropyUVTransform: mat3x3f,
 }
 
 @group(3) @binding(auto) var<uniform> pbrMaterial : pbrMaterialUniforms;
@@ -18368,13 +18692,22 @@ fn SRGBtoLINEAR(srgbIn: vec4f ) -> vec4f
   return vec4f(linOut, srgbIn.w);
 }
 
+fn getMaterialUV(uvSet: i32, uvTransform: mat3x3f) -> vec2f
+{
+  var baseUV = fragmentInputs.pbr_vUV0;
+  if (uvSet == 1) {
+    baseUV = fragmentInputs.pbr_vUV1;
+  }
+  return (uvTransform * vec3f(baseUV, 1.0)).xy;
+}
+
 // Build the tangent basis from interpolated attributes or screen-space derivatives.
-fn getTBN() -> mat3x3f
+fn getTBN(uv: vec2f) -> mat3x3f
 {
   let pos_dx: vec3f = dpdx(fragmentInputs.pbr_vPosition);
   let pos_dy: vec3f = dpdy(fragmentInputs.pbr_vPosition);
-  let tex_dx: vec3f = dpdx(vec3f(fragmentInputs.pbr_vUV, 0.0));
-  let tex_dy: vec3f = dpdy(vec3f(fragmentInputs.pbr_vUV, 0.0));
+  let tex_dx: vec3f = dpdx(vec3f(uv, 0.0));
+  let tex_dy: vec3f = dpdy(vec3f(uv, 0.0));
   var t: vec3f = (tex_dy.y * pos_dx - tex_dx.y * pos_dy) / (tex_dx.x * tex_dy.y - tex_dy.x * tex_dx.y);
 
   var ng: vec3f = cross(pos_dx, pos_dy);
@@ -18397,14 +18730,15 @@ fn getMappedNormal(
   normalSampler: texture_2d<f32>,
   normalSamplerBinding: sampler,
   tbn: mat3x3f,
-  normalScale: f32
+  normalScale: f32,
+  uv: vec2f
 ) -> vec3f
 {
-  let n = textureSample(normalSampler, normalSamplerBinding, fragmentInputs.pbr_vUV).rgb;
+  let n = textureSample(normalSampler, normalSamplerBinding, uv).rgb;
   return normalize(tbn * ((2.0 * n - 1.0) * vec3f(normalScale, normalScale, 1.0)));
 }
 
-fn getNormal(tbn: mat3x3f) -> vec3f
+fn getNormal(tbn: mat3x3f, uv: vec2f) -> vec3f
 {
   // The tbn matrix is linearly interpolated, so we need to re-normalize
   var n: vec3f = normalize(tbn[2].xyz);
@@ -18413,21 +18747,23 @@ fn getNormal(tbn: mat3x3f) -> vec3f
     pbr_normalSampler,
     pbr_normalSamplerSampler,
     tbn,
-    pbrMaterial.normalScale
+    pbrMaterial.normalScale,
+    uv
   );
 #endif
 
   return n;
 }
 
-fn getClearcoatNormal(tbn: mat3x3f, baseNormal: vec3f) -> vec3f
+fn getClearcoatNormal(tbn: mat3x3f, baseNormal: vec3f, uv: vec2f) -> vec3f
 {
 #ifdef HAS_CLEARCOATNORMALMAP
   return getMappedNormal(
     pbr_clearcoatNormalSampler,
     pbr_clearcoatNormalSamplerSampler,
     tbn,
-    1.0
+    1.0,
+    uv
   );
 #else
   return baseNormal;
@@ -18732,11 +19068,62 @@ fn calculateFinalColor(pbrInfo: PBRInfo, lightColor: vec3<f32>) -> vec3<f32> {
 }
 
 fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
+  let baseColorUV = getMaterialUV(pbrMaterial.baseColorUVSet, pbrMaterial.baseColorUVTransform);
+  let metallicRoughnessUV = getMaterialUV(
+    pbrMaterial.metallicRoughnessUVSet,
+    pbrMaterial.metallicRoughnessUVTransform
+  );
+  let normalUV = getMaterialUV(pbrMaterial.normalUVSet, pbrMaterial.normalUVTransform);
+  let occlusionUV = getMaterialUV(pbrMaterial.occlusionUVSet, pbrMaterial.occlusionUVTransform);
+  let emissiveUV = getMaterialUV(pbrMaterial.emissiveUVSet, pbrMaterial.emissiveUVTransform);
+  let specularColorUV = getMaterialUV(
+    pbrMaterial.specularColorUVSet,
+    pbrMaterial.specularColorUVTransform
+  );
+  let specularIntensityUV = getMaterialUV(
+    pbrMaterial.specularIntensityUVSet,
+    pbrMaterial.specularIntensityUVTransform
+  );
+  let transmissionUV = getMaterialUV(
+    pbrMaterial.transmissionUVSet,
+    pbrMaterial.transmissionUVTransform
+  );
+  let thicknessUV = getMaterialUV(pbrMaterial.thicknessUVSet, pbrMaterial.thicknessUVTransform);
+  let clearcoatUV = getMaterialUV(pbrMaterial.clearcoatUVSet, pbrMaterial.clearcoatUVTransform);
+  let clearcoatRoughnessUV = getMaterialUV(
+    pbrMaterial.clearcoatRoughnessUVSet,
+    pbrMaterial.clearcoatRoughnessUVTransform
+  );
+  let clearcoatNormalUV = getMaterialUV(
+    pbrMaterial.clearcoatNormalUVSet,
+    pbrMaterial.clearcoatNormalUVTransform
+  );
+  let sheenColorUV = getMaterialUV(
+    pbrMaterial.sheenColorUVSet,
+    pbrMaterial.sheenColorUVTransform
+  );
+  let sheenRoughnessUV = getMaterialUV(
+    pbrMaterial.sheenRoughnessUVSet,
+    pbrMaterial.sheenRoughnessUVTransform
+  );
+  let iridescenceUV = getMaterialUV(
+    pbrMaterial.iridescenceUVSet,
+    pbrMaterial.iridescenceUVTransform
+  );
+  let iridescenceThicknessUV = getMaterialUV(
+    pbrMaterial.iridescenceThicknessUVSet,
+    pbrMaterial.iridescenceThicknessUVTransform
+  );
+  let anisotropyUV = getMaterialUV(
+    pbrMaterial.anisotropyUVSet,
+    pbrMaterial.anisotropyUVTransform
+  );
+
   // The albedo may be defined from a base texture or a flat color
   var baseColor: vec4<f32> = pbrMaterial.baseColorFactor;
   #ifdef HAS_BASECOLORMAP
   baseColor = SRGBtoLINEAR(
-    textureSample(pbr_baseColorSampler, pbr_baseColorSamplerSampler, fragmentInputs.pbr_vUV)
+    textureSample(pbr_baseColorSampler, pbr_baseColorSamplerSampler, baseColorUV)
   ) * pbrMaterial.baseColorFactor;
   #endif
 
@@ -18763,15 +19150,15 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
     let mrSample = textureSample(
       pbr_metallicRoughnessSampler,
       pbr_metallicRoughnessSamplerSampler,
-      fragmentInputs.pbr_vUV
+      metallicRoughnessUV
     );
     perceptualRoughness = mrSample.g * perceptualRoughness;
     metallic = mrSample.b * metallic;
     #endif
     perceptualRoughness = clamp(perceptualRoughness, c_MinRoughness, 1.0);
     metallic = clamp(metallic, 0.0, 1.0);
-    let tbn = getTBN();
-    let n = getNormal(tbn);                          // normal at surface point
+    let tbn = getTBN(normalUV);
+    let n = getNormal(tbn, normalUV);                          // normal at surface point
     let v = normalize(pbrProjection.camera - fragmentInputs.pbr_vPosition);  // Vector from surface point to camera
     let NdotV = clamp(abs(dot(n, v)), 0.001, 1.0);
     var useExtendedPBR = false;
@@ -18876,8 +19263,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
 
       #ifdef HAS_OCCLUSIONMAP
       if (pbrMaterial.occlusionMapEnabled != 0) {
-        let ao =
-          textureSample(pbr_occlusionSampler, pbr_occlusionSamplerSampler, fragmentInputs.pbr_vUV).r;
+        let ao = textureSample(pbr_occlusionSampler, pbr_occlusionSamplerSampler, occlusionUV).r;
         color = mix(color, color * ao, pbrMaterial.occlusionStrength);
       }
       #endif
@@ -18886,7 +19272,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
       #ifdef HAS_EMISSIVEMAP
       if (pbrMaterial.emissiveMapEnabled != 0u) {
         emissive *= SRGBtoLINEAR(
-          textureSample(pbr_emissiveSampler, pbr_emissiveSamplerSampler, fragmentInputs.pbr_vUV)
+          textureSample(pbr_emissiveSampler, pbr_emissiveSamplerSampler, emissiveUV)
         ).rgb;
       }
       #endif
@@ -18907,7 +19293,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
       specularIntensity *= textureSample(
         pbr_specularIntensitySampler,
         pbr_specularIntensitySamplerSampler,
-        fragmentInputs.pbr_vUV
+        specularIntensityUV
       ).a;
     }
     #endif
@@ -18919,7 +19305,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
         textureSample(
           pbr_specularColorSampler,
           pbr_specularColorSamplerSampler,
-          fragmentInputs.pbr_vUV
+          specularColorUV
         )
       ).rgb;
     }
@@ -18931,7 +19317,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
       transmission *= textureSample(
         pbr_transmissionSampler,
         pbr_transmissionSamplerSampler,
-        fragmentInputs.pbr_vUV
+        transmissionUV
       ).r;
     }
     #endif
@@ -18941,7 +19327,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
     thickness *= textureSample(
       pbr_thicknessSampler,
       pbr_thicknessSamplerSampler,
-      fragmentInputs.pbr_vUV
+      thicknessUV
     ).g;
     #endif
 
@@ -18952,7 +19338,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
       clearcoatFactor *= textureSample(
         pbr_clearcoatSampler,
         pbr_clearcoatSamplerSampler,
-        fragmentInputs.pbr_vUV
+        clearcoatUV
       ).r;
     }
     #endif
@@ -18961,13 +19347,13 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
       clearcoatRoughness *= textureSample(
         pbr_clearcoatRoughnessSampler,
         pbr_clearcoatRoughnessSamplerSampler,
-        fragmentInputs.pbr_vUV
+        clearcoatRoughnessUV
       ).g;
     }
     #endif
     clearcoatFactor = clamp(clearcoatFactor, 0.0, 1.0);
     clearcoatRoughness = clamp(clearcoatRoughness, c_MinRoughness, 1.0);
-    let clearcoatNormal = getClearcoatNormal(tbn, n);
+    let clearcoatNormal = getClearcoatNormal(getTBN(clearcoatNormalUV), n, clearcoatNormalUV);
 
     var sheenColor = pbrMaterial.sheenColorFactor;
     var sheenRoughness = pbrMaterial.sheenRoughnessFactor;
@@ -18977,7 +19363,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
         textureSample(
           pbr_sheenColorSampler,
           pbr_sheenColorSamplerSampler,
-          fragmentInputs.pbr_vUV
+          sheenColorUV
         )
       ).rgb;
     }
@@ -18987,7 +19373,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
       sheenRoughness *= textureSample(
         pbr_sheenRoughnessSampler,
         pbr_sheenRoughnessSamplerSampler,
-        fragmentInputs.pbr_vUV
+        sheenRoughnessUV
       ).a;
     }
     #endif
@@ -18999,7 +19385,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
       iridescence *= textureSample(
         pbr_iridescenceSampler,
         pbr_iridescenceSamplerSampler,
-        fragmentInputs.pbr_vUV
+        iridescenceUV
       ).r;
     }
     #endif
@@ -19016,7 +19402,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
       textureSample(
         pbr_iridescenceThicknessSampler,
         pbr_iridescenceThicknessSamplerSampler,
-        fragmentInputs.pbr_vUV
+        iridescenceThicknessUV
       ).g
     );
     #endif
@@ -19028,7 +19414,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
       let anisotropySample = textureSample(
         pbr_anisotropySampler,
         pbr_anisotropySamplerSampler,
-        fragmentInputs.pbr_vUV
+        anisotropyUV
       ).rgb;
       anisotropyStrength *= anisotropySample.b;
       let mappedDirection = anisotropySample.rg * 2.0 - 1.0;
@@ -19195,8 +19581,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
     // Apply optional PBR terms for additional (optional) shading
     #ifdef HAS_OCCLUSIONMAP
     if (pbrMaterial.occlusionMapEnabled != 0) {
-      let ao =
-        textureSample(pbr_occlusionSampler, pbr_occlusionSamplerSampler, fragmentInputs.pbr_vUV).r;
+      let ao = textureSample(pbr_occlusionSampler, pbr_occlusionSamplerSampler, occlusionUV).r;
       color = mix(color, color * ao, pbrMaterial.occlusionStrength);
     }
     #endif
@@ -19205,7 +19590,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
     #ifdef HAS_EMISSIVEMAP
     if (pbrMaterial.emissiveMapEnabled != 0u) {
       emissive *= SRGBtoLINEAR(
-        textureSample(pbr_emissiveSampler, pbr_emissiveSamplerSampler, fragmentInputs.pbr_vUV)
+        textureSample(pbr_emissiveSampler, pbr_emissiveSamplerSampler, emissiveUV)
       ).rgb;
     }
     #endif
@@ -19325,7 +19710,41 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
       anisotropyRotation: 0,
       anisotropyDirection: [1, 0],
       anisotropyMapEnabled: false,
-      emissiveStrength: 1
+      emissiveStrength: 1,
+      baseColorUVSet: 0,
+      baseColorUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+      metallicRoughnessUVSet: 0,
+      metallicRoughnessUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+      normalUVSet: 0,
+      normalUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+      occlusionUVSet: 0,
+      occlusionUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+      emissiveUVSet: 0,
+      emissiveUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+      specularColorUVSet: 0,
+      specularColorUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+      specularIntensityUVSet: 0,
+      specularIntensityUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+      transmissionUVSet: 0,
+      transmissionUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+      thicknessUVSet: 0,
+      thicknessUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+      clearcoatUVSet: 0,
+      clearcoatUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+      clearcoatRoughnessUVSet: 0,
+      clearcoatRoughnessUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+      clearcoatNormalUVSet: 0,
+      clearcoatNormalUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+      sheenColorUVSet: 0,
+      sheenColorUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+      sheenRoughnessUVSet: 0,
+      sheenRoughnessUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+      iridescenceUVSet: 0,
+      iridescenceUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+      iridescenceThicknessUVSet: 0,
+      iridescenceThicknessUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+      anisotropyUVSet: 0,
+      anisotropyUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1]
     },
     name: "pbrMaterial",
     firstBindingSlot: 0,
@@ -19432,7 +19851,41 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
       // debugging flags used for shader output of intermediate PBR variables
       // #ifdef PBR_DEBUG
       scaleDiffBaseMR: "vec4<f32>",
-      scaleFGDSpec: "vec4<f32>"
+      scaleFGDSpec: "vec4<f32>",
+      baseColorUVSet: "i32",
+      baseColorUVTransform: "mat3x3<f32>",
+      metallicRoughnessUVSet: "i32",
+      metallicRoughnessUVTransform: "mat3x3<f32>",
+      normalUVSet: "i32",
+      normalUVTransform: "mat3x3<f32>",
+      occlusionUVSet: "i32",
+      occlusionUVTransform: "mat3x3<f32>",
+      emissiveUVSet: "i32",
+      emissiveUVTransform: "mat3x3<f32>",
+      specularColorUVSet: "i32",
+      specularColorUVTransform: "mat3x3<f32>",
+      specularIntensityUVSet: "i32",
+      specularIntensityUVTransform: "mat3x3<f32>",
+      transmissionUVSet: "i32",
+      transmissionUVTransform: "mat3x3<f32>",
+      thicknessUVSet: "i32",
+      thicknessUVTransform: "mat3x3<f32>",
+      clearcoatUVSet: "i32",
+      clearcoatUVTransform: "mat3x3<f32>",
+      clearcoatRoughnessUVSet: "i32",
+      clearcoatRoughnessUVTransform: "mat3x3<f32>",
+      clearcoatNormalUVSet: "i32",
+      clearcoatNormalUVTransform: "mat3x3<f32>",
+      sheenColorUVSet: "i32",
+      sheenColorUVTransform: "mat3x3<f32>",
+      sheenRoughnessUVSet: "i32",
+      sheenRoughnessUVTransform: "mat3x3<f32>",
+      iridescenceUVSet: "i32",
+      iridescenceUVTransform: "mat3x3<f32>",
+      iridescenceThicknessUVSet: "i32",
+      iridescenceThicknessUVTransform: "mat3x3<f32>",
+      anisotropyUVSet: "i32",
+      anisotropyUVTransform: "mat3x3<f32>"
     }
   };
 
@@ -19524,11 +19977,12 @@ void main(void) {
     #endif
 
     #ifdef HAS_UV
-      pbr_vUV = uv;
+      pbr_vUV0 = uv;
     #else
-      pbr_vUV = vec2(0., 0.);
+      pbr_vUV0 = vec2(0., 0.);
     #endif
-    geometry.uv = pbr_vUV;
+    pbr_vUV1 = vec2(0., 0.);
+    geometry.uv = pbr_vUV0;
   #endif
 
   DECKGL_FILTER_COLOR(vColor, geometry);
@@ -19556,7 +20010,7 @@ void main(void) {
 #ifdef MODULE_PBRMATERIAL
 
   fragColor = vColor * pbr_filterColor(vec4(0));
-  geometry.uv = pbr_vUV;
+  geometry.uv = pbr_vUV0;
   fragColor.a *= layer.opacity;
 
 #else
@@ -19723,7 +20177,7 @@ void main(void) {
   MeshLayer.defaultProps = defaultProps11;
 
   // src/tile-3d-layer/tile-3d-layer.ts
-  var import_core47 = __toESM(require_core2(), 1);
+  var import_core48 = __toESM(require_core2(), 1);
 
   // ../../node_modules/@math.gl/geospatial/dist/constants.js
   var WGS84_RADIUS_X = 6378137;
@@ -20439,7 +20893,7 @@ void main(void) {
   }
 
   // ../../node_modules/@loaders.gl/tiles/dist/tileset/tile-3d.js
-  var import_core33 = __toESM(require_core2(), 1);
+  var import_core34 = __toESM(require_core2(), 1);
 
   // ../../node_modules/@loaders.gl/tiles/dist/constants.js
   var TILE_CONTENT_STATE = {
@@ -21412,7 +21866,7 @@ void main(void) {
           }
           // TODO add typecheck - as const satisfies ...
         };
-        this.content = await (0, import_core33.load)(contentUrl, loader, options);
+        this.content = await (0, import_core34.load)(contentUrl, loader, options);
         if (this.tileset.options.contentLoader) {
           await this.tileset.options.contentLoader(this);
         }
@@ -21696,7 +22150,7 @@ void main(void) {
   };
 
   // ../../node_modules/@loaders.gl/tiles/dist/tileset/format-i3s/i3s-tileset-traverser.js
-  var import_core34 = __toESM(require_core2(), 1);
+  var import_core35 = __toESM(require_core2(), 1);
 
   // ../../node_modules/@loaders.gl/tiles/dist/tileset/format-i3s/i3s-pending-tiles-register.js
   var I3SPendingTilesRegister = class {
@@ -21860,7 +22314,7 @@ void main(void) {
           isTileHeader: true
         }
       };
-      return await (0, import_core34.load)(nodeUrl, loader, options);
+      return await (0, import_core35.load)(nodeUrl, loader, options);
     }
     /**
      * The callback to init Tile3D instance after loading the tile JSON
@@ -22587,7 +23041,7 @@ void main(void) {
   };
 
   // ../../node_modules/@loaders.gl/3d-tiles/dist/lib/utils/version.js
-  var VERSION9 = true ? "4.4.0-alpha.18" : "latest";
+  var VERSION9 = true ? "4.4.1" : "latest";
 
   // ../../node_modules/@loaders.gl/3d-tiles/dist/lib/constants.js
   var TILE3D_TYPE = {
@@ -22706,7 +23160,7 @@ void main(void) {
   }
 
   // ../../node_modules/@loaders.gl/draco/dist/lib/utils/version.js
-  var VERSION10 = true ? "4.4.0-alpha.18" : "latest";
+  var VERSION10 = true ? "4.4.1" : "latest";
 
   // ../../node_modules/@loaders.gl/schema-utils/dist/lib/schema/data-type.js
   function getDataTypeFromTypedArray(array) {
@@ -26142,7 +26596,7 @@ void main(void) {
   }
 
   // ../../node_modules/@loaders.gl/gltf/dist/lib/utils/version.js
-  var VERSION11 = true ? "4.4.0-alpha.18" : "latest";
+  var VERSION11 = true ? "4.4.1" : "latest";
 
   // ../../node_modules/@loaders.gl/gltf/dist/lib/parsers/parse-glb.js
   var LITTLE_ENDIAN2 = true;
@@ -26255,16 +26709,26 @@ void main(void) {
   }
 
   // ../../node_modules/@loaders.gl/gltf/dist/lib/gltf-utils/resolve-url.js
-  function resolveUrl(url, options) {
+  function resolveUrl(url, options, context) {
     const absolute = url.startsWith("data:") || url.startsWith("http:") || url.startsWith("https:");
     if (absolute) {
       return url;
     }
-    const baseUrl = options?.core?.baseUri || options.baseUri || options.uri;
+    const baseUrl = context?.baseUrl || getResolveBaseUrl(options?.core?.baseUrl);
     if (!baseUrl) {
-      throw new Error(`'baseUri' must be provided to resolve relative url ${url}`);
+      throw new Error(`'baseUrl' must be provided to resolve relative url ${url}`);
     }
-    return baseUrl.substr(0, baseUrl.lastIndexOf("/") + 1) + url;
+    return baseUrl.endsWith("/") ? `${baseUrl}${url}` : `${baseUrl}/${url}`;
+  }
+  function getResolveBaseUrl(baseUrl) {
+    if (!baseUrl) {
+      return void 0;
+    }
+    if (baseUrl.endsWith("/")) {
+      return baseUrl;
+    }
+    const slashIndex = baseUrl.lastIndexOf("/");
+    return slashIndex >= 0 ? baseUrl.slice(0, slashIndex + 1) : "";
   }
 
   // ../../node_modules/@loaders.gl/gltf/dist/lib/extensions/EXT_meshopt_compression.js
@@ -27301,8 +27765,8 @@ void main(void) {
     return gltf;
   }
   function parseGLTFContainerSync(gltf, data, byteOffset, options) {
-    if (options.core?.baseUri) {
-      gltf.baseUri = options.core?.baseUri;
+    if (options.core?.baseUrl) {
+      gltf.baseUri = options.core?.baseUrl;
     }
     if (data instanceof ArrayBuffer && !isGLB(data, byteOffset, options.glb)) {
       const textDecoder = new TextDecoder();
@@ -27339,7 +27803,7 @@ void main(void) {
       if (buffer.uri) {
         const { fetch: fetch2 } = context;
         assert8(fetch2);
-        const uri = resolveUrl(buffer.uri, options);
+        const uri = resolveUrl(buffer.uri, options, context);
         const response = await context?.fetch?.(uri);
         const arrayBuffer = await response?.arrayBuffer?.();
         gltf.buffers[i] = {
@@ -27379,7 +27843,7 @@ void main(void) {
   async function loadImage(gltf, image, index, options, context) {
     let arrayBuffer;
     if (image.uri && !image.hasOwnProperty("bufferView")) {
-      const uri = resolveUrl(image.uri, options);
+      const uri = resolveUrl(image.uri, options, context);
       const { fetch: fetch2 } = context;
       const response = await fetch2(uri);
       arrayBuffer = await response.arrayBuffer();
@@ -28193,10 +28657,10 @@ void main(void) {
   };
 
   // ../../node_modules/@loaders.gl/3d-tiles/dist/lib/parsers/parse-3d-tile-header.js
-  var import_core45 = __toESM(require_core2(), 1);
+  var import_core46 = __toESM(require_core2(), 1);
 
   // ../../node_modules/@loaders.gl/3d-tiles/dist/lib/parsers/helpers/parse-3d-implicit-tiles.js
-  var import_core44 = __toESM(require_core2(), 1);
+  var import_core45 = __toESM(require_core2(), 1);
 
   // ../../node_modules/@loaders.gl/3d-tiles/node_modules/long/index.js
   var wasm = null;
@@ -29474,7 +29938,7 @@ void main(void) {
     if (isChildSubtreeAvailable) {
       const subtreePath = `${basePath}/${subtreesUriTemplate}`;
       const childSubtreeUrl = replaceContentUrlTemplate(subtreePath, level, x, y, z);
-      const childSubtree = await (0, import_core44.load)(childSubtreeUrl, Tile3DSubtreeLoader, loaderOptions);
+      const childSubtree = await (0, import_core45.load)(childSubtreeUrl, Tile3DSubtreeLoader, loaderOptions);
       nextSubtree = childSubtree;
       tileAvailabilityIndex = 0;
       nextSubtreeData = { level, x, y, z };
@@ -29703,7 +30167,7 @@ void main(void) {
     const { subdivisionScheme, maximumLevel, availableLevels, subtreeLevels, subtrees: { uri: subtreesUriTemplate } } = implicitTilingExtension;
     const replacedUrlTemplate = replaceContentUrlTemplate(subtreesUriTemplate, 0, 0, 0, 0);
     const subtreeUrl = resolveUri(replacedUrlTemplate, basePath);
-    const subtree = await (0, import_core45.load)(subtreeUrl, Tile3DSubtreeLoader, options);
+    const subtree = await (0, import_core46.load)(subtreeUrl, Tile3DSubtreeLoader, options);
     const tileContentUri = tile.content?.uri;
     const contentUrlTemplate = tileContentUri ? resolveUri(tileContentUri, basePath) : "";
     const refine = tileset?.root?.refine;
@@ -29847,10 +30311,10 @@ void main(void) {
     } },
     _getMeshColor: { type: "function", value: (tileHeader) => [255, 255, 255] }
   };
-  var Tile3DLayer = class extends import_core46.CompositeLayer {
+  var Tile3DLayer = class extends import_core47.CompositeLayer {
     initializeState() {
       if ("onTileLoadFail" in this.props) {
-        import_core46.log.removed("onTileLoadFail", "onTileError")();
+        import_core47.log.removed("onTileLoadFail", "onTileError")();
       }
       this.state = {
         layerMap: {},
@@ -29960,7 +30424,7 @@ void main(void) {
         }
         Object.assign(options, preloadOptions);
       }
-      const tilesetJson = await (0, import_core47.load)(actualTilesetUrl, loader, options.loadOptions);
+      const tilesetJson = await (0, import_core48.load)(actualTilesetUrl, loader, options.loadOptions);
       const tileset3d = new Tileset3D(tilesetJson, {
         onTileLoad: this._onTileLoad.bind(this),
         onTileUnload: this._onTileUnload.bind(this),
@@ -30047,7 +30511,7 @@ void main(void) {
           id: `${this.id}-pointcloud-${tileHeader.id}`,
           tile: tileHeader,
           data,
-          coordinateSystem: import_core46.COORDINATE_SYSTEM.METER_OFFSETS,
+          coordinateSystem: import_core47.COORDINATE_SYSTEM.METER_OFFSETS,
           coordinateOrigin: cartographicOrigin,
           modelMatrix,
           getColor: constantRGBA || getPointColor,
@@ -30070,7 +30534,7 @@ void main(void) {
           tile: tileHeader,
           data: instances || SINGLE_DATA,
           scenegraph: gltf,
-          coordinateSystem: import_core46.COORDINATE_SYSTEM.METER_OFFSETS,
+          coordinateSystem: import_core47.COORDINATE_SYSTEM.METER_OFFSETS,
           coordinateOrigin: cartographicOrigin,
           modelMatrix,
           getTransformMatrix: (instance) => instance.modelMatrix,
@@ -30089,7 +30553,7 @@ void main(void) {
         indices,
         modelMatrix,
         cartographicOrigin,
-        coordinateSystem = import_core46.COORDINATE_SYSTEM.METER_OFFSETS,
+        coordinateSystem = import_core47.COORDINATE_SYSTEM.METER_OFFSETS,
         material,
         featureIds
       } = content;
@@ -30164,9 +30628,9 @@ void main(void) {
   }
 
   // src/terrain-layer/terrain-layer.ts
-  var import_core48 = __toESM(require_core(), 1);
-  var import_mesh_layers3 = __toESM(require_mesh_layers(), 1);
   var import_core49 = __toESM(require_core(), 1);
+  var import_mesh_layers3 = __toESM(require_mesh_layers(), 1);
+  var import_core50 = __toESM(require_core(), 1);
 
   // ../../node_modules/@loaders.gl/terrain/dist/lib/decode-quantized-mesh.js
   var QUANTIZED_MESH_HEADER = /* @__PURE__ */ new Map([
@@ -31127,7 +31591,7 @@ void main(void) {
   }
 
   // ../../node_modules/@loaders.gl/terrain/dist/lib/utils/version.js
-  var VERSION12 = true ? "4.4.0-alpha.18" : "latest";
+  var VERSION12 = true ? "4.4.1" : "latest";
 
   // ../../node_modules/@loaders.gl/terrain/dist/terrain-loader.js
   var TerrainLoader = {
@@ -31234,7 +31698,7 @@ void main(void) {
     }
     return template || "";
   }
-  var TerrainLayer = class extends import_core48.CompositeLayer {
+  var TerrainLayer = class extends import_core49.CompositeLayer {
     updateState({ props, oldProps }) {
       const elevationDataChanged = props.elevationData !== oldProps.elevationData;
       if (elevationDataChanged) {
@@ -31248,7 +31712,7 @@ void main(void) {
         this.setState({ terrain });
       }
       if (props.workerUrl) {
-        import_core48.log.removed("workerUrl", "loadOptions.terrain.workerUrl")();
+        import_core49.log.removed("workerUrl", "loadOptions.terrain.workerUrl")();
       }
     }
     loadTerrain({
@@ -31319,7 +31783,7 @@ void main(void) {
         mesh,
         texture,
         _instanced: false,
-        coordinateSystem: import_core49.COORDINATE_SYSTEM.CARTESIAN,
+        coordinateSystem: import_core50.COORDINATE_SYSTEM.CARTESIAN,
         getPosition: (d2) => [0, 0, 0],
         getColor: color,
         wireframe,
@@ -31424,7 +31888,7 @@ void main(void) {
   var isTileSetURL = (url) => url.includes("{x}") && (url.includes("{y}") || url.includes("{-y}"));
 
   // src/mvt-layer/mvt-layer.ts
-  var import_core51 = __toESM(require_core(), 1);
+  var import_core52 = __toESM(require_core(), 1);
   var import_layers9 = __toESM(require_layers(), 1);
   var import_extensions = __toESM(require_extensions(), 1);
 
@@ -32999,7 +33463,7 @@ void main(void) {
   };
 
   // ../../node_modules/@loaders.gl/mvt/dist/mvt-loader.js
-  var VERSION13 = true ? "4.4.0-alpha.18" : "latest";
+  var VERSION13 = true ? "4.4.1" : "latest";
   var MVTWorkerLoader = {
     ...MVTFormat,
     dataType: null,
@@ -33280,12 +33744,12 @@ void main(void) {
       if (!this.context.viewport.resolution) {
         props.modelMatrix = modelMatrix;
         props.coordinateOrigin = [xOffset, yOffset, 0];
-        props.coordinateSystem = import_core51.COORDINATE_SYSTEM.CARTESIAN;
+        props.coordinateSystem = import_core52.COORDINATE_SYSTEM.CARTESIAN;
         props.extensions = [...props.extensions || [], new import_extensions.ClipExtension()];
       }
       const subLayers = super.renderSubLayers(props);
       if (this.state.binary && !(subLayers instanceof import_layers9.GeoJsonLayer)) {
-        import_core51.log.warn("renderSubLayers() must return GeoJsonLayer when using binary:true")();
+        import_core52.log.warn("renderSubLayers() must return GeoJsonLayer when using binary:true")();
       }
       return subLayers;
     }