@deck.gl/geo-layers 9.3.0-alpha.3 → 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() {
@@ -14996,7 +15028,12 @@ var __exports__ = (() => {
     get isLoaded() {
       return Boolean(
         this.state?.tileset?.selectedTiles?.every(
-          (tile) => tile.isLoaded && tile.layers && tile.layers.every((layer) => layer.isLoaded)
+          (tile) => (
+            // Error / empty tiles resolve to `content === null`. Once Tile2DHeader marks those
+            // requests as loaded, do not wait for generated sublayers because there is nothing to
+            // render for that tile and `tile.layers` will remain null.
+            tile.isLoaded && (!tile.content || !tile.layers || tile.layers.every((layer) => layer.isLoaded))
+          )
         )
       );
     }
@@ -15033,7 +15070,9 @@ var __exports__ = (() => {
         minZoom,
         maxRequests,
         debounceTime,
-        zoomOffset
+        zoomOffset,
+        visibleMinZoom,
+        visibleMaxZoom
       } = this.props;
       return {
         maxCacheSize,
@@ -15046,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),
@@ -15121,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) {
@@ -15166,7 +15216,7 @@ var __exports__ = (() => {
   var import_layers6 = __toESM(require_layers(), 1);
 
   // src/trips-layer/trips-layer-uniforms.ts
-  var uniformBlock = `uniform tripsUniforms {
+  var uniformBlock = `layout(std140) uniform tripsUniforms {
   bool fadeTrail;
   float trailLength;
   float currentTime;
@@ -15508,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 = {
@@ -15632,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",
@@ -15648,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: [
@@ -15748,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,
@@ -15853,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));
@@ -16017,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 {
@@ -16037,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",
@@ -16082,7 +16148,36 @@ 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;
+  (function(GLEnum2) {
+    GLEnum2[GLEnum2["POINTS"] = 0] = "POINTS";
+    GLEnum2[GLEnum2["LINES"] = 1] = "LINES";
+    GLEnum2[GLEnum2["LINE_LOOP"] = 2] = "LINE_LOOP";
+    GLEnum2[GLEnum2["LINE_STRIP"] = 3] = "LINE_STRIP";
+    GLEnum2[GLEnum2["TRIANGLES"] = 4] = "TRIANGLES";
+    GLEnum2[GLEnum2["TRIANGLE_STRIP"] = 5] = "TRIANGLE_STRIP";
+    GLEnum2[GLEnum2["TRIANGLE_FAN"] = 6] = "TRIANGLE_FAN";
+    GLEnum2[GLEnum2["ONE"] = 1] = "ONE";
+    GLEnum2[GLEnum2["SRC_ALPHA"] = 770] = "SRC_ALPHA";
+    GLEnum2[GLEnum2["ONE_MINUS_SRC_ALPHA"] = 771] = "ONE_MINUS_SRC_ALPHA";
+    GLEnum2[GLEnum2["FUNC_ADD"] = 32774] = "FUNC_ADD";
+    GLEnum2[GLEnum2["LINEAR"] = 9729] = "LINEAR";
+    GLEnum2[GLEnum2["NEAREST"] = 9728] = "NEAREST";
+    GLEnum2[GLEnum2["NEAREST_MIPMAP_NEAREST"] = 9984] = "NEAREST_MIPMAP_NEAREST";
+    GLEnum2[GLEnum2["LINEAR_MIPMAP_NEAREST"] = 9985] = "LINEAR_MIPMAP_NEAREST";
+    GLEnum2[GLEnum2["NEAREST_MIPMAP_LINEAR"] = 9986] = "NEAREST_MIPMAP_LINEAR";
+    GLEnum2[GLEnum2["LINEAR_MIPMAP_LINEAR"] = 9987] = "LINEAR_MIPMAP_LINEAR";
+    GLEnum2[GLEnum2["TEXTURE_MIN_FILTER"] = 10241] = "TEXTURE_MIN_FILTER";
+    GLEnum2[GLEnum2["TEXTURE_WRAP_S"] = 10242] = "TEXTURE_WRAP_S";
+    GLEnum2[GLEnum2["TEXTURE_WRAP_T"] = 10243] = "TEXTURE_WRAP_T";
+    GLEnum2[GLEnum2["REPEAT"] = 10497] = "REPEAT";
+    GLEnum2[GLEnum2["CLAMP_TO_EDGE"] = 33071] = "CLAMP_TO_EDGE";
+    GLEnum2[GLEnum2["MIRRORED_REPEAT"] = 33648] = "MIRRORED_REPEAT";
+    GLEnum2[GLEnum2["UNPACK_FLIP_Y_WEBGL"] = 37440] = "UNPACK_FLIP_Y_WEBGL";
+  })(GLEnum || (GLEnum = {}));
 
   // ../../node_modules/@luma.gl/gltf/dist/webgl-to-webgpu/convert-webgl-sampler.js
   function convertSampler(gltfSampler) {
@@ -16095,11 +16190,11 @@ out float vTime;
   }
   function convertSamplerWrapMode(mode) {
     switch (mode) {
-      case 33071:
+      case GLEnum.CLAMP_TO_EDGE:
         return "clamp-to-edge";
-      case 10497:
+      case GLEnum.REPEAT:
         return "repeat";
-      case 33648:
+      case GLEnum.MIRRORED_REPEAT:
         return "mirror-repeat";
       default:
         return void 0;
@@ -16107,9 +16202,9 @@ out float vTime;
   }
   function convertSamplerMagFilter(mode) {
     switch (mode) {
-      case 9728:
+      case GLEnum.NEAREST:
         return "nearest";
-      case 9729:
+      case GLEnum.LINEAR:
         return "linear";
       default:
         return void 0;
@@ -16117,23 +16212,92 @@ out float vTime;
   }
   function convertSamplerMinFilter(mode) {
     switch (mode) {
-      case 9728:
+      case GLEnum.NEAREST:
         return { minFilter: "nearest" };
-      case 9729:
+      case GLEnum.LINEAR:
         return { minFilter: "linear" };
-      case 9984:
+      case GLEnum.NEAREST_MIPMAP_NEAREST:
         return { minFilter: "nearest", mipmapFilter: "nearest" };
-      case 9985:
+      case GLEnum.LINEAR_MIPMAP_NEAREST:
         return { minFilter: "linear", mipmapFilter: "nearest" };
-      case 9986:
+      case GLEnum.NEAREST_MIPMAP_LINEAR:
         return { minFilter: "nearest", mipmapFilter: "linear" };
-      case 9987:
+      case GLEnum.LINEAR_MIPMAP_LINEAR:
         return { minFilter: "linear", mipmapFilter: "linear" };
       default:
         return {};
     }
   }
 
+  // ../../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 = {
@@ -16159,7 +16323,8 @@ out float vTime;
     if (imageBasedLightingEnvironment) {
       parsedMaterial.bindings.pbr_diffuseEnvSampler = imageBasedLightingEnvironment.diffuseEnvSampler.texture;
       parsedMaterial.bindings.pbr_specularEnvSampler = imageBasedLightingEnvironment.specularEnvSampler.texture;
-      parsedMaterial.bindings.pbr_BrdfLUT = imageBasedLightingEnvironment.brdfLutTexture.texture;
+      parsedMaterial.bindings.pbr_brdfLUT = imageBasedLightingEnvironment.brdfLutTexture.texture;
+      parsedMaterial.uniforms.IBLenabled = true;
       parsedMaterial.uniforms.scaleIBLAmbient = [1, 1];
     }
     if (options?.pbrDebug) {
@@ -16173,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"])
@@ -16182,68 +16349,439 @@ out float vTime;
     if (options?.lights)
       parsedMaterial.defines["USE_LIGHTS"] = true;
     if (material) {
-      parseMaterial(device, material, parsedMaterial);
+      if (options.validateAttributes !== false) {
+        warnOnMissingExpectedAttributes(material, attributes);
+      }
+      parseMaterial(device, material, parsedMaterial, attributes, options.gltf);
     }
     return parsedMaterial;
   }
-  function parseMaterial(device, material, parsedMaterial) {
-    parsedMaterial.uniforms.unlit = Boolean(material.unlit);
+  function warnOnMissingExpectedAttributes(material, attributes) {
+    const uvDependentTextureSlots = getUvDependentTextureSlots(material, 0);
+    if (uvDependentTextureSlots.length > 0 && !attributes["TEXCOORD_0"]) {
+      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_core21.log.warn(`glTF primitive is missing NORMAL while using ${missingNormalReason}; shading will fall back to geometric normals`)();
+  }
+  function getUvDependentTextureSlots(material, textureCoordinateSet) {
+    const uvDependentTextureSlots = [];
+    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 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);
+      parsePbrMetallicRoughness(device, material.pbrMetallicRoughness, parsedMaterial, attributes, gltf);
     }
     if (material.normalTexture) {
-      addTexture(device, material.normalTexture, "pbr_normalSampler", "HAS_NORMALMAP", parsedMaterial);
+      addTexture(device, material.normalTexture, "pbr_normalSampler", parsedMaterial, {
+        featureOptions: {
+          define: "HAS_NORMALMAP",
+          enabledUniformName: "normalMapEnabled"
+        },
+        gltf,
+        attributes,
+        textureTransformSlot: "normal"
+      });
       const { scale: scale12 = 1 } = material.normalTexture;
       parsedMaterial.uniforms.normalScale = scale12;
     }
     if (material.occlusionTexture) {
-      addTexture(device, material.occlusionTexture, "pbr_occlusionSampler", "HAS_OCCLUSIONMAP", parsedMaterial);
+      addTexture(device, material.occlusionTexture, "pbr_occlusionSampler", parsedMaterial, {
+        featureOptions: {
+          define: "HAS_OCCLUSIONMAP",
+          enabledUniformName: "occlusionMapEnabled"
+        },
+        gltf,
+        attributes,
+        textureTransformSlot: "occlusion"
+      });
       const { strength = 1 } = material.occlusionTexture;
       parsedMaterial.uniforms.occlusionStrength = strength;
     }
+    parsedMaterial.uniforms.emissiveFactor = material.emissiveFactor || [0, 0, 0];
     if (material.emissiveTexture) {
-      addTexture(device, material.emissiveTexture, "pbr_emissiveSampler", "HAS_EMISSIVEMAP", parsedMaterial);
-      parsedMaterial.uniforms.emissiveFactor = material.emissiveFactor || [0, 0, 0];
+      addTexture(device, material.emissiveTexture, "pbr_emissiveSampler", parsedMaterial, {
+        featureOptions: {
+          define: "HAS_EMISSIVEMAP",
+          enabledUniformName: "emissiveMapEnabled"
+        },
+        gltf,
+        attributes,
+        textureTransformSlot: "emissive"
+      });
     }
-    switch (material.alphaMode || "MASK") {
-      case "MASK":
+    parseMaterialExtensions(device, material.extensions, parsedMaterial, gltf, attributes);
+    switch (material.alphaMode || "OPAQUE") {
+      case "OPAQUE":
+        break;
+      case "MASK": {
         const { alphaCutoff = 0.5 } = material;
         parsedMaterial.defines["ALPHA_CUTOFF"] = true;
+        parsedMaterial.uniforms.alphaCutoffEnabled = true;
         parsedMaterial.uniforms.alphaCutoff = alphaCutoff;
         break;
+      }
       case "BLEND":
-        import_core20.log.warn("glTF BLEND alphaMode might not work well because it requires mesh sorting")();
-        parsedMaterial.parameters.blend = true;
-        parsedMaterial.parameters.blendColorOperation = "add";
-        parsedMaterial.parameters.blendColorSrcFactor = "src-alpha";
-        parsedMaterial.parameters.blendColorDstFactor = "one-minus-src-alpha";
-        parsedMaterial.parameters.blendAlphaOperation = "add";
-        parsedMaterial.parameters.blendAlphaSrcFactor = "one";
-        parsedMaterial.parameters.blendAlphaDstFactor = "one-minus-src-alpha";
-        parsedMaterial.glParameters["blend"] = true;
-        parsedMaterial.glParameters["blendEquation"] = 32774;
-        parsedMaterial.glParameters["blendFunc"] = [
-          770,
-          771,
-          1,
-          771
-        ];
+        import_core21.log.warn("glTF BLEND alphaMode might not work well because it requires mesh sorting")();
+        applyAlphaBlendParameters(parsedMaterial);
         break;
     }
   }
-  function parsePbrMetallicRoughness(device, pbrMetallicRoughness, parsedMaterial) {
+  function applyAlphaBlendParameters(parsedMaterial) {
+    parsedMaterial.parameters.blend = true;
+    parsedMaterial.parameters.blendColorOperation = "add";
+    parsedMaterial.parameters.blendColorSrcFactor = "src-alpha";
+    parsedMaterial.parameters.blendColorDstFactor = "one-minus-src-alpha";
+    parsedMaterial.parameters.blendAlphaOperation = "add";
+    parsedMaterial.parameters.blendAlphaSrcFactor = "one";
+    parsedMaterial.parameters.blendAlphaDstFactor = "one-minus-src-alpha";
+    parsedMaterial.glParameters["blend"] = true;
+    parsedMaterial.glParameters["blendEquation"] = GLEnum.FUNC_ADD;
+    parsedMaterial.glParameters["blendFunc"] = [
+      GLEnum.SRC_ALPHA,
+      GLEnum.ONE_MINUS_SRC_ALPHA,
+      GLEnum.ONE,
+      GLEnum.ONE_MINUS_SRC_ALPHA
+    ];
+  }
+  function applyTransmissionBlendApproximation(parsedMaterial) {
+    parsedMaterial.parameters.blend = true;
+    parsedMaterial.parameters.depthWriteEnabled = false;
+    parsedMaterial.parameters.blendColorOperation = "add";
+    parsedMaterial.parameters.blendColorSrcFactor = "one";
+    parsedMaterial.parameters.blendColorDstFactor = "one-minus-src-alpha";
+    parsedMaterial.parameters.blendAlphaOperation = "add";
+    parsedMaterial.parameters.blendAlphaSrcFactor = "one";
+    parsedMaterial.parameters.blendAlphaDstFactor = "one-minus-src-alpha";
+    parsedMaterial.glParameters["blend"] = true;
+    parsedMaterial.glParameters["depthMask"] = false;
+    parsedMaterial.glParameters["blendEquation"] = GLEnum.FUNC_ADD;
+    parsedMaterial.glParameters["blendFunc"] = [
+      GLEnum.ONE,
+      GLEnum.ONE_MINUS_SRC_ALPHA,
+      GLEnum.ONE,
+      GLEnum.ONE_MINUS_SRC_ALPHA
+    ];
+  }
+  function parsePbrMetallicRoughness(device, pbrMetallicRoughness, parsedMaterial, attributes, gltf) {
     if (pbrMetallicRoughness.baseColorTexture) {
-      addTexture(device, pbrMetallicRoughness.baseColorTexture, "pbr_baseColorSampler", "HAS_BASECOLORMAP", parsedMaterial);
+      addTexture(device, pbrMetallicRoughness.baseColorTexture, "pbr_baseColorSampler", parsedMaterial, {
+        featureOptions: {
+          define: "HAS_BASECOLORMAP",
+          enabledUniformName: "baseColorMapEnabled"
+        },
+        gltf,
+        attributes,
+        textureTransformSlot: "baseColor"
+      });
     }
     parsedMaterial.uniforms.baseColorFactor = pbrMetallicRoughness.baseColorFactor || [1, 1, 1, 1];
     if (pbrMetallicRoughness.metallicRoughnessTexture) {
-      addTexture(device, pbrMetallicRoughness.metallicRoughnessTexture, "pbr_metallicRoughnessSampler", "HAS_METALROUGHNESSMAP", parsedMaterial);
+      addTexture(device, pbrMetallicRoughness.metallicRoughnessTexture, "pbr_metallicRoughnessSampler", parsedMaterial, {
+        featureOptions: {
+          define: "HAS_METALROUGHNESSMAP",
+          enabledUniformName: "metallicRoughnessMapEnabled"
+        },
+        gltf,
+        attributes,
+        textureTransformSlot: "metallicRoughness"
+      });
     }
     const { metallicFactor = 1, roughnessFactor = 1 } = pbrMetallicRoughness;
     parsedMaterial.uniforms.metallicRoughnessValues = [metallicFactor, roughnessFactor];
   }
-  function addTexture(device, gltfTexture, uniformName, define2, parsedMaterial) {
-    const image = gltfTexture.texture.source.image;
+  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, attributes);
+    parseIorExtension(extensions.KHR_materials_ior, parsedMaterial);
+    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, attributes = {}) {
+    if (!extension) {
+      return;
+    }
+    if (extension.specularColorFactor) {
+      parsedMaterial.uniforms.specularColorFactor = extension.specularColorFactor;
+    }
+    if (extension.specularFactor !== void 0) {
+      parsedMaterial.uniforms.specularIntensityFactor = extension.specularFactor;
+    }
+    if (extension.specularColorTexture) {
+      addTexture(device, extension.specularColorTexture, "pbr_specularColorSampler", parsedMaterial, {
+        featureOptions: {
+          define: "HAS_SPECULARCOLORMAP",
+          enabledUniformName: "specularColorMapEnabled"
+        },
+        gltf,
+        attributes,
+        textureTransformSlot: "specularColor"
+      });
+    }
+    if (extension.specularTexture) {
+      addTexture(device, extension.specularTexture, "pbr_specularIntensitySampler", parsedMaterial, {
+        featureOptions: {
+          define: "HAS_SPECULARINTENSITYMAP",
+          enabledUniformName: "specularIntensityMapEnabled"
+        },
+        gltf,
+        attributes,
+        textureTransformSlot: "specularIntensity"
+      });
+    }
+  }
+  function parseIorExtension(extension, parsedMaterial) {
+    if (extension?.ior !== void 0) {
+      parsedMaterial.uniforms.ior = extension.ior;
+    }
+  }
+  function parseTransmissionExtension(device, extension, parsedMaterial, gltf, attributes = {}) {
+    if (!extension) {
+      return;
+    }
+    if (extension.transmissionFactor !== void 0) {
+      parsedMaterial.uniforms.transmissionFactor = extension.transmissionFactor;
+    }
+    if (extension.transmissionTexture) {
+      addTexture(device, extension.transmissionTexture, "pbr_transmissionSampler", parsedMaterial, {
+        featureOptions: {
+          define: "HAS_TRANSMISSIONMAP",
+          enabledUniformName: "transmissionMapEnabled"
+        },
+        gltf,
+        attributes,
+        textureTransformSlot: "transmission"
+      });
+    }
+    if ((extension.transmissionFactor ?? 0) > 0 || extension.transmissionTexture) {
+      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, attributes = {}) {
+    if (!extension) {
+      return;
+    }
+    if (extension.thicknessFactor !== void 0) {
+      parsedMaterial.uniforms.thicknessFactor = extension.thicknessFactor;
+    }
+    if (extension.thicknessTexture) {
+      addTexture(device, extension.thicknessTexture, "pbr_thicknessSampler", parsedMaterial, {
+        featureOptions: {
+          define: "HAS_THICKNESSMAP"
+        },
+        gltf,
+        attributes,
+        textureTransformSlot: "thickness"
+      });
+    }
+    if (extension.attenuationDistance !== void 0) {
+      parsedMaterial.uniforms.attenuationDistance = extension.attenuationDistance;
+    }
+    if (extension.attenuationColor) {
+      parsedMaterial.uniforms.attenuationColor = extension.attenuationColor;
+    }
+  }
+  function parseClearcoatExtension(device, extension, parsedMaterial, gltf, attributes = {}) {
+    if (!extension) {
+      return;
+    }
+    if (extension.clearcoatFactor !== void 0) {
+      parsedMaterial.uniforms.clearcoatFactor = extension.clearcoatFactor;
+    }
+    if (extension.clearcoatRoughnessFactor !== void 0) {
+      parsedMaterial.uniforms.clearcoatRoughnessFactor = extension.clearcoatRoughnessFactor;
+    }
+    if (extension.clearcoatTexture) {
+      addTexture(device, extension.clearcoatTexture, "pbr_clearcoatSampler", parsedMaterial, {
+        featureOptions: {
+          define: "HAS_CLEARCOATMAP",
+          enabledUniformName: "clearcoatMapEnabled"
+        },
+        gltf,
+        attributes,
+        textureTransformSlot: "clearcoat"
+      });
+    }
+    if (extension.clearcoatRoughnessTexture) {
+      addTexture(device, extension.clearcoatRoughnessTexture, "pbr_clearcoatRoughnessSampler", parsedMaterial, {
+        featureOptions: {
+          define: "HAS_CLEARCOATROUGHNESSMAP",
+          enabledUniformName: "clearcoatRoughnessMapEnabled"
+        },
+        gltf,
+        attributes,
+        textureTransformSlot: "clearcoatRoughness"
+      });
+    }
+    if (extension.clearcoatNormalTexture) {
+      addTexture(device, extension.clearcoatNormalTexture, "pbr_clearcoatNormalSampler", parsedMaterial, {
+        featureOptions: {
+          define: "HAS_CLEARCOATNORMALMAP"
+        },
+        gltf,
+        attributes,
+        textureTransformSlot: "clearcoatNormal"
+      });
+    }
+  }
+  function parseSheenExtension(device, extension, parsedMaterial, gltf, attributes = {}) {
+    if (!extension) {
+      return;
+    }
+    if (extension.sheenColorFactor) {
+      parsedMaterial.uniforms.sheenColorFactor = extension.sheenColorFactor;
+    }
+    if (extension.sheenRoughnessFactor !== void 0) {
+      parsedMaterial.uniforms.sheenRoughnessFactor = extension.sheenRoughnessFactor;
+    }
+    if (extension.sheenColorTexture) {
+      addTexture(device, extension.sheenColorTexture, "pbr_sheenColorSampler", parsedMaterial, {
+        featureOptions: {
+          define: "HAS_SHEENCOLORMAP",
+          enabledUniformName: "sheenColorMapEnabled"
+        },
+        gltf,
+        attributes,
+        textureTransformSlot: "sheenColor"
+      });
+    }
+    if (extension.sheenRoughnessTexture) {
+      addTexture(device, extension.sheenRoughnessTexture, "pbr_sheenRoughnessSampler", parsedMaterial, {
+        featureOptions: {
+          define: "HAS_SHEENROUGHNESSMAP",
+          enabledUniformName: "sheenRoughnessMapEnabled"
+        },
+        gltf,
+        attributes,
+        textureTransformSlot: "sheenRoughness"
+      });
+    }
+  }
+  function parseIridescenceExtension(device, extension, parsedMaterial, gltf, attributes = {}) {
+    if (!extension) {
+      return;
+    }
+    if (extension.iridescenceFactor !== void 0) {
+      parsedMaterial.uniforms.iridescenceFactor = extension.iridescenceFactor;
+    }
+    if (extension.iridescenceIor !== void 0) {
+      parsedMaterial.uniforms.iridescenceIor = extension.iridescenceIor;
+    }
+    if (extension.iridescenceThicknessMinimum !== void 0 || extension.iridescenceThicknessMaximum !== void 0) {
+      parsedMaterial.uniforms.iridescenceThicknessRange = [
+        extension.iridescenceThicknessMinimum ?? 100,
+        extension.iridescenceThicknessMaximum ?? 400
+      ];
+    }
+    if (extension.iridescenceTexture) {
+      addTexture(device, extension.iridescenceTexture, "pbr_iridescenceSampler", parsedMaterial, {
+        featureOptions: {
+          define: "HAS_IRIDESCENCEMAP",
+          enabledUniformName: "iridescenceMapEnabled"
+        },
+        gltf,
+        attributes,
+        textureTransformSlot: "iridescence"
+      });
+    }
+    if (extension.iridescenceThicknessTexture) {
+      addTexture(device, extension.iridescenceThicknessTexture, "pbr_iridescenceThicknessSampler", parsedMaterial, {
+        featureOptions: {
+          define: "HAS_IRIDESCENCETHICKNESSMAP"
+        },
+        gltf,
+        attributes,
+        textureTransformSlot: "iridescenceThickness"
+      });
+    }
+  }
+  function parseAnisotropyExtension(device, extension, parsedMaterial, gltf, attributes = {}) {
+    if (!extension) {
+      return;
+    }
+    if (extension.anisotropyStrength !== void 0) {
+      parsedMaterial.uniforms.anisotropyStrength = extension.anisotropyStrength;
+    }
+    if (extension.anisotropyRotation !== void 0) {
+      parsedMaterial.uniforms.anisotropyRotation = extension.anisotropyRotation;
+    }
+    if (extension.anisotropyTexture) {
+      addTexture(device, extension.anisotropyTexture, "pbr_anisotropySampler", parsedMaterial, {
+        featureOptions: {
+          define: "HAS_ANISOTROPYMAP",
+          enabledUniformName: "anisotropyMapEnabled"
+        },
+        gltf,
+        attributes,
+        textureTransformSlot: "anisotropy"
+      });
+    }
+  }
+  function parseEmissiveStrengthExtension(extension, parsedMaterial) {
+    if (extension?.emissiveStrength !== void 0) {
+      parsedMaterial.uniforms.emissiveStrength = extension.emissiveStrength;
+    }
+  }
+  function addTexture(device, gltfTexture, uniformName, parsedMaterial, 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_core21.log.warn(`Skipping unresolved glTF texture for ${String(uniformName)}`)();
+      return;
+    }
     const gltfSampler = {
       wrapS: 10497,
       // default REPEAT S (U) wrapping mode.
@@ -16253,10 +16791,10 @@ out float vTime;
       // default LINEAR filtering
       magFilter: 9729,
       // default LINEAR filtering
-      ...gltfTexture?.texture?.sampler
+      ...resolvedTextureInfo?.texture?.sampler
     };
     const baseOptions = {
-      id: gltfTexture.uniformName || gltfTexture.id,
+      id: resolvedTextureInfo.uniformName || resolvedTextureInfo.id,
       sampler: convertSampler(gltfSampler)
     };
     let texture;
@@ -16274,8 +16812,39 @@ out float vTime;
     parsedMaterial.bindings[uniformName] = texture;
     if (define2)
       parsedMaterial.defines[define2] = true;
+    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) {
+    if (gltfTexture.texture || gltfTexture.index === void 0 || !gltf?.textures) {
+      return gltfTexture;
+    }
+    const resolvedTextureEntry = gltf.textures[gltfTexture.index];
+    if (!resolvedTextureEntry) {
+      return gltfTexture;
+    }
+    if ("texture" in resolvedTextureEntry && resolvedTextureEntry.texture) {
+      return {
+        ...resolvedTextureEntry,
+        ...gltfTexture,
+        texture: resolvedTextureEntry.texture
+      };
+    }
+    if (!("source" in resolvedTextureEntry)) {
+      return gltfTexture;
+    }
+    return {
+      ...gltfTexture,
+      texture: resolvedTextureEntry
+    };
+  }
   function createCompressedTextureFallback(device, baseOptions) {
     return device.createTexture({
       ...baseOptions,
@@ -16289,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);
@@ -16310,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);
@@ -16331,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++;
@@ -16350,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,
@@ -16366,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 = (
@@ -16385,77 +16965,51 @@ struct PointLight {
   vec3 attenuation; // 2nd order x:Constant-y:Linear-z:Exponential
 };
 
+struct SpotLight {
+  vec3 color;
+  vec3 position;
+  vec3 direction;
+  vec3 attenuation;
+  vec2 coneCos;
+};
+
 struct DirectionalLight {
   vec3 color;
   vec3 direction;
 };
 
-uniform lightingUniforms {
-  int enabled;
-  int lightType;
+struct UniformLight {
+  vec3 color;
+  vec3 position;
+  vec3 direction;
+  vec3 attenuation;
+  vec2 coneCos;
+};
 
+layout(std140) uniform lightingUniforms {
+  int enabled;
   int directionalLightCount;
   int pointLightCount;
-
+  int spotLightCount;
   vec3 ambientColor;
-
-  vec3 lightColor0;
-  vec3 lightPosition0;
-  vec3 lightDirection0;
-  vec3 lightAttenuation0;
-
-  vec3 lightColor1;
-  vec3 lightPosition1;
-  vec3 lightDirection1;
-  vec3 lightAttenuation1;
-
-  vec3 lightColor2;
-  vec3 lightPosition2;
-  vec3 lightDirection2;
-  vec3 lightAttenuation2;
-
-  vec3 lightColor3;
-  vec3 lightPosition3;
-  vec3 lightDirection3;
-  vec3 lightAttenuation3;
-
-  vec3 lightColor4;
-  vec3 lightPosition4;
-  vec3 lightDirection4;
-  vec3 lightAttenuation4;
+  UniformLight lights[5];
 } lighting;
 
 PointLight lighting_getPointLight(int index) {
-  switch (index) {
-    case 0:
-      return PointLight(lighting.lightColor0, lighting.lightPosition0, lighting.lightAttenuation0);
-    case 1:
-      return PointLight(lighting.lightColor1, lighting.lightPosition1, lighting.lightAttenuation1);
-    case 2:
-      return PointLight(lighting.lightColor2, lighting.lightPosition2, lighting.lightAttenuation2);
-    case 3:
-      return PointLight(lighting.lightColor3, lighting.lightPosition3, lighting.lightAttenuation3);
-    case 4:
-    default:  
-      return PointLight(lighting.lightColor4, lighting.lightPosition4, lighting.lightAttenuation4);
-  }
+  UniformLight light = lighting.lights[index];
+  return PointLight(light.color, light.position, light.attenuation);
+}
+
+SpotLight lighting_getSpotLight(int index) {
+  UniformLight light = lighting.lights[lighting.pointLightCount + index];
+  return SpotLight(light.color, light.position, light.direction, light.attenuation, light.coneCos);
 }
 
 DirectionalLight lighting_getDirectionalLight(int index) {
-  switch (index) {
-    case 0:
-      return DirectionalLight(lighting.lightColor0, lighting.lightDirection0);
-    case 1:
-      return DirectionalLight(lighting.lightColor1, lighting.lightDirection1);
-    case 2:
-      return DirectionalLight(lighting.lightColor2, lighting.lightDirection2);
-    case 3:
-      return DirectionalLight(lighting.lightColor3, lighting.lightDirection3);
-    case 4:
-    default:   
-      return DirectionalLight(lighting.lightColor4, lighting.lightDirection4);
-  }
-} 
+  UniformLight light =
+    lighting.lights[lighting.pointLightCount + lighting.spotLightCount + index];
+  return DirectionalLight(light.color, light.direction);
+}
 
 float getPointLightAttenuation(PointLight pointLight, float distance) {
   return pointLight.attenuation.x
@@ -16463,6 +17017,20 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
        + pointLight.attenuation.z * distance * distance;
 }
 
+float getSpotLightAttenuation(SpotLight spotLight, vec3 positionWorldspace) {
+  vec3 light_direction = normalize(positionWorldspace - spotLight.position);
+  float coneFactor = smoothstep(
+    spotLight.coneCos.y,
+    spotLight.coneCos.x,
+    dot(normalize(spotLight.direction), light_direction)
+  );
+  float distanceAttenuation = getPointLightAttenuation(
+    PointLight(spotLight.color, spotLight.position, spotLight.attenuation),
+    distance(spotLight.position, positionWorldspace)
+  );
+  return distanceAttenuation / max(coneFactor, 0.0001);
+}
+
 // #endif
 `
   );
@@ -16483,105 +17051,84 @@ struct PointLight {
   attenuation: vec3<f32>, // 2nd order x:Constant-y:Linear-z:Exponential
 };
 
+struct SpotLight {
+  color: vec3<f32>,
+  position: vec3<f32>,
+  direction: vec3<f32>,
+  attenuation: vec3<f32>,
+  coneCos: vec2<f32>,
+};
+
 struct DirectionalLight {
   color: vec3<f32>,
   direction: vec3<f32>,
 };
 
+struct UniformLight {
+  color: vec3<f32>,
+  position: vec3<f32>,
+  direction: vec3<f32>,
+  attenuation: vec3<f32>,
+  coneCos: vec2<f32>,
+};
+
 struct lightingUniforms {
   enabled: i32,
-  lightType: i32,
-
   directionalLightCount: i32,
   pointLightCount: i32,
-
+  spotLightCount: i32,
   ambientColor: vec3<f32>,
-
-  lightColor0: vec3<f32>,
-  lightPosition0: vec3<f32>,
-  lightDirection0: vec3<f32>,
-  lightAttenuation0: vec3<f32>,
-
-  lightColor1: vec3<f32>,
-  lightPosition1: vec3<f32>,
-  lightDirection1: vec3<f32>,
-  lightAttenuation1: vec3<f32>,
-
-  lightColor2: vec3<f32>,
-  lightPosition2: vec3<f32>,
-  lightDirection2: vec3<f32>,
-  lightAttenuation2: vec3<f32>,
-
-  lightColor3: vec3<f32>,
-  lightPosition3: vec3<f32>,
-  lightDirection3: vec3<f32>,
-  lightAttenuation3: vec3<f32>,
-
-  lightColor4: vec3<f32>,
-  lightPosition4: vec3<f32>,
-  lightDirection4: vec3<f32>,
-  lightAttenuation4: vec3<f32>,
+  lights: array<UniformLight, 5>,
 };
 
-// Binding 0:1 is reserved for lighting (Note: could go into separate bind group as it is stable across draw calls)
-@binding(1) @group(0) var<uniform> lighting : lightingUniforms;
+@group(2) @binding(auto) var<uniform> lighting : lightingUniforms;
 
 fn lighting_getPointLight(index: i32) -> PointLight {
-  switch (index) {
-    case 0: {
-      return PointLight(lighting.lightColor0, lighting.lightPosition0, lighting.lightAttenuation0);
-    }
-    case 1: {
-      return PointLight(lighting.lightColor1, lighting.lightPosition1, lighting.lightAttenuation1);
-    }
-    case 2: {
-      return PointLight(lighting.lightColor2, lighting.lightPosition2, lighting.lightAttenuation2);
-    }
-    case 3: {
-      return PointLight(lighting.lightColor3, lighting.lightPosition3, lighting.lightAttenuation3);
-    }
-    case 4, default: {
-      return PointLight(lighting.lightColor4, lighting.lightPosition4, lighting.lightAttenuation4);
-    }
-  }
+  let light = lighting.lights[index];
+  return PointLight(light.color, light.position, light.attenuation);
+}
+
+fn lighting_getSpotLight(index: i32) -> SpotLight {
+  let light = lighting.lights[lighting.pointLightCount + index];
+  return SpotLight(light.color, light.position, light.direction, light.attenuation, light.coneCos);
 }
 
 fn lighting_getDirectionalLight(index: i32) -> DirectionalLight {
-  switch (index) {
-    case 0: {
-      return DirectionalLight(lighting.lightColor0, lighting.lightDirection0);
-    }
-    case 1: {
-      return DirectionalLight(lighting.lightColor1, lighting.lightDirection1);
-    }
-    case 2: {
-      return DirectionalLight(lighting.lightColor2, lighting.lightDirection2);
-    }
-    case 3: {
-      return DirectionalLight(lighting.lightColor3, lighting.lightDirection3);
-    }
-    case 4, default: {
-      return DirectionalLight(lighting.lightColor4, lighting.lightDirection4);
-    }
-  }
-} 
+  let light = lighting.lights[lighting.pointLightCount + lighting.spotLightCount + index];
+  return DirectionalLight(light.color, light.direction);
+}
 
 fn getPointLightAttenuation(pointLight: PointLight, distance: f32) -> f32 {
   return pointLight.attenuation.x
        + pointLight.attenuation.y * distance
        + pointLight.attenuation.z * distance * distance;
 }
+
+fn getSpotLightAttenuation(spotLight: SpotLight, positionWorldspace: vec3<f32>) -> f32 {
+  let lightDirection = normalize(positionWorldspace - spotLight.position);
+  let coneFactor = smoothstep(
+    spotLight.coneCos.y,
+    spotLight.coneCos.x,
+    dot(normalize(spotLight.direction), lightDirection)
+  );
+  let distanceAttenuation = getPointLightAttenuation(
+    PointLight(spotLight.color, spotLight.position, spotLight.attenuation),
+    distance(spotLight.position, positionWorldspace)
+  );
+  return distanceAttenuation / max(coneFactor, 0.0001);
+}
 `
   );
 
   // ../../node_modules/@luma.gl/shadertools/dist/modules/lighting/lights/lighting.js
   var MAX_LIGHTS = 5;
-  var COLOR_FACTOR = 255;
-  var LIGHT_TYPE;
-  (function(LIGHT_TYPE2) {
-    LIGHT_TYPE2[LIGHT_TYPE2["POINT"] = 0] = "POINT";
-    LIGHT_TYPE2[LIGHT_TYPE2["DIRECTIONAL"] = 1] = "DIRECTIONAL";
-  })(LIGHT_TYPE || (LIGHT_TYPE = {}));
+  var LIGHT_UNIFORM_TYPE = {
+    color: "vec3<f32>",
+    position: "vec3<f32>",
+    direction: "vec3<f32>",
+    attenuation: "vec3<f32>",
+    coneCos: "vec2<f32>"
+  };
   var lighting = {
     props: {},
     uniforms: {},
@@ -16591,127 +17138,110 @@ fn getPointLightAttenuation(pointLight: PointLight, distance: f32) -> f32 {
     },
     uniformTypes: {
       enabled: "i32",
-      lightType: "i32",
       directionalLightCount: "i32",
       pointLightCount: "i32",
+      spotLightCount: "i32",
       ambientColor: "vec3<f32>",
-      // TODO define as arrays once we have appropriate uniformTypes
-      lightColor0: "vec3<f32>",
-      lightPosition0: "vec3<f32>",
-      // TODO - could combine direction and attenuation
-      lightDirection0: "vec3<f32>",
-      lightAttenuation0: "vec3<f32>",
-      lightColor1: "vec3<f32>",
-      lightPosition1: "vec3<f32>",
-      lightDirection1: "vec3<f32>",
-      lightAttenuation1: "vec3<f32>",
-      lightColor2: "vec3<f32>",
-      lightPosition2: "vec3<f32>",
-      lightDirection2: "vec3<f32>",
-      lightAttenuation2: "vec3<f32>",
-      lightColor3: "vec3<f32>",
-      lightPosition3: "vec3<f32>",
-      lightDirection3: "vec3<f32>",
-      lightAttenuation3: "vec3<f32>",
-      lightColor4: "vec3<f32>",
-      lightPosition4: "vec3<f32>",
-      lightDirection4: "vec3<f32>",
-      lightAttenuation4: "vec3<f32>"
-    },
-    defaultUniforms: {
-      enabled: 1,
-      lightType: LIGHT_TYPE.POINT,
-      directionalLightCount: 0,
-      pointLightCount: 0,
-      ambientColor: [0.1, 0.1, 0.1],
-      lightColor0: [1, 1, 1],
-      lightPosition0: [1, 1, 2],
-      // TODO - could combine direction and attenuation
-      lightDirection0: [1, 1, 1],
-      lightAttenuation0: [1, 0, 0],
-      lightColor1: [1, 1, 1],
-      lightPosition1: [1, 1, 2],
-      lightDirection1: [1, 1, 1],
-      lightAttenuation1: [1, 0, 0],
-      lightColor2: [1, 1, 1],
-      lightPosition2: [1, 1, 2],
-      lightDirection2: [1, 1, 1],
-      lightAttenuation2: [1, 0, 0],
-      lightColor3: [1, 1, 1],
-      lightPosition3: [1, 1, 2],
-      lightDirection3: [1, 1, 1],
-      lightAttenuation3: [1, 0, 0],
-      lightColor4: [1, 1, 1],
-      lightPosition4: [1, 1, 2],
-      lightDirection4: [1, 1, 1],
-      lightAttenuation4: [1, 0, 0]
+      lights: [LIGHT_UNIFORM_TYPE, MAX_LIGHTS]
     },
+    defaultUniforms: createDefaultLightingUniforms(),
+    bindingLayout: [{ name: "lighting", group: 2 }],
+    firstBindingSlot: 0,
     source: lightingUniformsWGSL,
     vs: lightingUniformsGLSL,
     fs: lightingUniformsGLSL,
     getUniforms
   };
-  function getUniforms(props, prevUniforms = {}) {
+  function getUniforms(props, _prevUniforms = {}) {
     props = props ? { ...props } : props;
     if (!props) {
-      return { ...lighting.defaultUniforms };
+      return createDefaultLightingUniforms();
     }
     if (props.lights) {
       props = { ...props, ...extractLightTypes(props.lights), lights: void 0 };
     }
-    const { ambientLight, pointLights, directionalLights } = props || {};
-    const hasLights = ambientLight || pointLights && pointLights.length > 0 || directionalLights && directionalLights.length > 0;
+    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 { ...lighting.defaultUniforms, enabled: 0 };
+      return {
+        ...createDefaultLightingUniforms(),
+        enabled: 0
+      };
     }
     const uniforms = {
-      ...lighting.defaultUniforms,
-      ...prevUniforms,
-      ...getLightSourceUniforms({ ambientLight, pointLights, directionalLights })
+      ...createDefaultLightingUniforms(),
+      ...getLightSourceUniforms({
+        useByteColors,
+        ambientLight,
+        pointLights,
+        spotLights,
+        directionalLights
+      })
     };
     if (props.enabled !== void 0) {
       uniforms.enabled = props.enabled ? 1 : 0;
     }
     return uniforms;
   }
-  function getLightSourceUniforms({ ambientLight, pointLights = [], directionalLights = [] }) {
-    const lightSourceUniforms = {};
-    lightSourceUniforms.ambientColor = convertColor(ambientLight);
+  function getLightSourceUniforms({ useByteColors, ambientLight, pointLights = [], spotLights = [], directionalLights = [] }) {
+    const lights = createDefaultLightUniforms();
     let currentLight = 0;
     let pointLightCount = 0;
+    let spotLightCount = 0;
     let directionalLightCount = 0;
     for (const pointLight of pointLights) {
       if (currentLight >= MAX_LIGHTS) {
         break;
       }
-      lightSourceUniforms.lightType = LIGHT_TYPE.POINT;
-      const i = currentLight;
-      lightSourceUniforms[`lightColor${i}`] = convertColor(pointLight);
-      lightSourceUniforms[`lightPosition${i}`] = pointLight.position;
-      lightSourceUniforms[`lightAttenuation${i}`] = pointLight.attenuation || [1, 0, 0];
+      lights[currentLight] = {
+        ...lights[currentLight],
+        color: convertColor(pointLight, useByteColors),
+        position: pointLight.position,
+        attenuation: pointLight.attenuation || [1, 0, 0]
+      };
       currentLight++;
       pointLightCount++;
     }
+    for (const spotLight of spotLights) {
+      if (currentLight >= MAX_LIGHTS) {
+        break;
+      }
+      lights[currentLight] = {
+        ...lights[currentLight],
+        color: convertColor(spotLight, useByteColors),
+        position: spotLight.position,
+        direction: spotLight.direction,
+        attenuation: spotLight.attenuation || [1, 0, 0],
+        coneCos: getSpotConeCos(spotLight)
+      };
+      currentLight++;
+      spotLightCount++;
+    }
     for (const directionalLight of directionalLights) {
       if (currentLight >= MAX_LIGHTS) {
         break;
       }
-      lightSourceUniforms.lightType = LIGHT_TYPE.DIRECTIONAL;
-      const i = currentLight;
-      lightSourceUniforms[`lightColor${i}`] = convertColor(directionalLight);
-      lightSourceUniforms[`lightDirection${i}`] = directionalLight.direction;
+      lights[currentLight] = {
+        ...lights[currentLight],
+        color: convertColor(directionalLight, useByteColors),
+        direction: directionalLight.direction
+      };
       currentLight++;
       directionalLightCount++;
     }
-    if (pointLights.length + directionalLights.length > MAX_LIGHTS) {
-      import_core21.log.warn(`MAX_LIGHTS exceeded, truncating to ${MAX_LIGHTS}`)();
+    if (pointLights.length + spotLights.length + directionalLights.length > MAX_LIGHTS) {
+      import_core22.log.warn(`MAX_LIGHTS exceeded, truncating to ${MAX_LIGHTS}`)();
     }
-    lightSourceUniforms.directionalLightCount = directionalLightCount;
-    lightSourceUniforms.pointLightCount = pointLightCount;
-    return lightSourceUniforms;
+    return {
+      ambientColor: convertColor(ambientLight, useByteColors),
+      directionalLightCount,
+      pointLightCount,
+      spotLightCount,
+      lights
+    };
   }
   function extractLightTypes(lights) {
-    const lightSources = { pointLights: [], directionalLights: [] };
+    const lightSources = { pointLights: [], spotLights: [], directionalLights: [] };
     for (const light of lights || []) {
       switch (light.type) {
         case "ambient":
@@ -16723,21 +17253,88 @@ fn getPointLightAttenuation(pointLight: PointLight, distance: f32) -> f32 {
         case "point":
           lightSources.pointLights?.push(light);
           break;
+        case "spot":
+          lightSources.spotLights?.push(light);
+          break;
         default:
       }
     }
     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 {
+      enabled: 1,
+      directionalLightCount: 0,
+      pointLightCount: 0,
+      spotLightCount: 0,
+      ambientColor: [0.1, 0.1, 0.1],
+      lights: createDefaultLightUniforms()
+    };
+  }
+  function createDefaultLightUniforms() {
+    return Array.from({ length: MAX_LIGHTS }, () => createDefaultLightUniform());
+  }
+  function createDefaultLightUniform() {
+    return {
+      color: [1, 1, 1],
+      position: [1, 1, 2],
+      direction: [1, 1, 1],
+      attenuation: [1, 0, 0],
+      coneCos: [1, 0]
+    };
+  }
+  function getSpotConeCos(spotLight) {
+    const innerConeAngle = spotLight.innerConeAngle ?? 0;
+    const outerConeAngle = spotLight.outerConeAngle ?? Math.PI / 4;
+    return [Math.cos(innerConeAngle), Math.cos(outerConeAngle)];
   }
 
+  // ../../node_modules/@luma.gl/shadertools/dist/modules/lighting/ibl/ibl.js
+  var iblWGSL = (
+    /* wgsl */
+    `#ifdef USE_IBL
+@group(2) @binding(auto) var pbr_diffuseEnvSampler: texture_cube<f32>;
+@group(2) @binding(auto) var pbr_diffuseEnvSamplerSampler: sampler;
+@group(2) @binding(auto) var pbr_specularEnvSampler: texture_cube<f32>;
+@group(2) @binding(auto) var pbr_specularEnvSamplerSampler: sampler;
+@group(2) @binding(auto) var pbr_brdfLUT: texture_2d<f32>;
+@group(2) @binding(auto) var pbr_brdfLUTSampler: sampler;
+#endif
+`
+  );
+  var iblGLSL = (
+    /* glsl */
+    `#ifdef USE_IBL
+uniform samplerCube pbr_diffuseEnvSampler;
+uniform samplerCube pbr_specularEnvSampler;
+uniform sampler2D pbr_brdfLUT;
+#endif
+`
+  );
+  var ibl = {
+    name: "ibl",
+    firstBindingSlot: 32,
+    bindingLayout: [
+      { name: "pbr_diffuseEnvSampler", group: 2 },
+      { name: "pbr_specularEnvSampler", group: 2 },
+      { name: "pbr_brdfLUT", group: 2 }
+    ],
+    source: iblWGSL,
+    vs: iblGLSL,
+    fs: iblGLSL
+  };
+
   // ../../node_modules/@luma.gl/shadertools/dist/modules/lighting/pbr-material/pbr-material-glsl.js
   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
@@ -16747,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;
@@ -16764,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;
 }
 `
   );
@@ -16775,7 +17380,7 @@ void pbr_setPositionNormalTangentUV(vec4 position, vec4 normal, vec4 tangent, ve
     /* glsl */
     `precision highp float;
 
-uniform pbrMaterialUniforms {
+layout(std140) uniform pbrMaterialUniforms {
   // Material is unlit
   bool unlit;
 
@@ -16815,10 +17420,12 @@ uniform pbrMaterialUniforms {
   float clearcoatFactor;
   float clearcoatRoughnessFactor;
   bool clearcoatMapEnabled;
+  bool clearcoatRoughnessMapEnabled;
 
   vec3 sheenColorFactor;
   float sheenRoughnessFactor;
   bool sheenColorMapEnabled;
+  bool sheenRoughnessMapEnabled;
 
   float iridescenceFactor;
   float iridescenceIor;
@@ -16841,6 +17448,41 @@ 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
@@ -16868,30 +17510,38 @@ uniform sampler2D pbr_specularIntensitySampler;
 #ifdef HAS_TRANSMISSIONMAP
 uniform sampler2D pbr_transmissionSampler;
 #endif
+#ifdef HAS_THICKNESSMAP
+uniform sampler2D pbr_thicknessSampler;
+#endif
 #ifdef HAS_CLEARCOATMAP
 uniform sampler2D pbr_clearcoatSampler;
+#endif
+#ifdef HAS_CLEARCOATROUGHNESSMAP
 uniform sampler2D pbr_clearcoatRoughnessSampler;
 #endif
+#ifdef HAS_CLEARCOATNORMALMAP
+uniform sampler2D pbr_clearcoatNormalSampler;
+#endif
 #ifdef HAS_SHEENCOLORMAP
 uniform sampler2D pbr_sheenColorSampler;
+#endif
+#ifdef HAS_SHEENROUGHNESSMAP
 uniform sampler2D pbr_sheenRoughnessSampler;
 #endif
 #ifdef HAS_IRIDESCENCEMAP
 uniform sampler2D pbr_iridescenceSampler;
 #endif
+#ifdef HAS_IRIDESCENCETHICKNESSMAP
+uniform sampler2D pbr_iridescenceThicknessSampler;
+#endif
 #ifdef HAS_ANISOTROPYMAP
 uniform sampler2D pbr_anisotropySampler;
 #endif
-#ifdef USE_IBL
-uniform samplerCube pbr_diffuseEnvSampler;
-uniform samplerCube pbr_specularEnvSampler;
-uniform sampler2D pbr_brdfLUT;
-#endif
-
 // 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
@@ -16924,6 +17574,8 @@ struct PBRInfo {
 const float M_PI = 3.141592653589793;
 const float c_MinRoughness = 0.04;
 
+vec3 calculateFinalColor(PBRInfo pbrInfo, vec3 lightColor);
+
 vec4 SRGBtoLINEAR(vec4 srgbIn)
 {
 #ifdef MANUAL_SRGB
@@ -16939,16 +17591,20 @@ vec4 SRGBtoLINEAR(vec4 srgbIn)
 #endif //MANUAL_SRGB
 }
 
-// Find the normal for this fragment, pulling either from a predefined normal map
-// or from the interpolated mesh normal and tangent attributes.
-vec3 getNormal()
+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(vec2 uv)
 {
-  // Retrieve the tangent space matrix
 #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
@@ -16964,9 +17620,21 @@ vec3 getNormal()
   mat3 tbn = pbr_vTBN;
 #endif
 
+  return tbn;
+}
+
+// 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, vec2 uv)
+{
+  vec3 n = texture(normalSampler, uv).rgb;
+  return normalize(tbn * ((2.0 * n - 1.0) * vec3(normalScale, normalScale, 1.0)));
+}
+
+vec3 getNormal(mat3 tbn, vec2 uv)
+{
 #ifdef HAS_NORMALMAP
-  vec3 n = texture(pbr_normalSampler, pbr_vUV).rgb;
-  n = normalize(tbn * ((2.0 * n - 1.0) * vec3(pbrMaterial.normalScale, pbrMaterial.normalScale, 1.0)));
+  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);
@@ -16975,6 +17643,15 @@ vec3 getNormal()
   return n;
 }
 
+vec3 getClearcoatNormal(mat3 tbn, vec3 baseNormal, vec2 uv)
+{
+#ifdef HAS_CLEARCOATNORMALMAP
+  return getMappedNormal(pbr_clearcoatNormalSampler, tbn, 1.0, uv);
+#else
+  return baseNormal;
+#endif
+}
+
 // Calculation of the lighting contribution from an optional Image Based Light source.
 // Precomputed Environment Maps are required uniform inputs and are computed as outlined in [1].
 // See our README.md on Environment Maps [3] for additional discussion.
@@ -17050,6 +17727,169 @@ float microfacetDistribution(PBRInfo pbrInfo)
   return roughnessSq / (M_PI * f * f);
 }
 
+float maxComponent(vec3 value)
+{
+  return max(max(value.r, value.g), value.b);
+}
+
+float getDielectricF0(float ior)
+{
+  float clampedIor = max(ior, 1.0);
+  float ratio = (clampedIor - 1.0) / (clampedIor + 1.0);
+  return ratio * ratio;
+}
+
+vec2 normalizeDirection(vec2 direction)
+{
+  float directionLength = length(direction);
+  return directionLength > 0.0001 ? direction / directionLength : vec2(1.0, 0.0);
+}
+
+vec2 rotateDirection(vec2 direction, float rotation)
+{
+  float s = sin(rotation);
+  float c = cos(rotation);
+  return vec2(direction.x * c - direction.y * s, direction.x * s + direction.y * c);
+}
+
+vec3 getIridescenceTint(float iridescence, float thickness, float NdotV)
+{
+  if (iridescence <= 0.0) {
+    return vec3(1.0);
+  }
+
+  float phase = 0.015 * thickness * pbrMaterial.iridescenceIor + (1.0 - NdotV) * 6.0;
+  vec3 thinFilmTint =
+    0.5 + 0.5 * cos(vec3(phase, phase + 2.0943951, phase + 4.1887902));
+  return mix(vec3(1.0), thinFilmTint, iridescence);
+}
+
+vec3 getVolumeAttenuation(float thickness)
+{
+  if (thickness <= 0.0) {
+    return vec3(1.0);
+  }
+
+  vec3 attenuationCoefficient =
+    -log(max(pbrMaterial.attenuationColor, vec3(0.0001))) /
+    max(pbrMaterial.attenuationDistance, 0.0001);
+  return exp(-attenuationCoefficient * thickness);
+}
+
+PBRInfo createClearcoatPBRInfo(PBRInfo basePBRInfo, vec3 clearcoatNormal, float clearcoatRoughness)
+{
+  float perceptualRoughness = clamp(clearcoatRoughness, c_MinRoughness, 1.0);
+  float alphaRoughness = perceptualRoughness * perceptualRoughness;
+  float NdotV = clamp(abs(dot(clearcoatNormal, basePBRInfo.v)), 0.001, 1.0);
+
+  return PBRInfo(
+    basePBRInfo.NdotL,
+    NdotV,
+    basePBRInfo.NdotH,
+    basePBRInfo.LdotH,
+    basePBRInfo.VdotH,
+    perceptualRoughness,
+    0.0,
+    vec3(0.04),
+    vec3(1.0),
+    alphaRoughness,
+    vec3(0.0),
+    vec3(0.04),
+    clearcoatNormal,
+    basePBRInfo.v
+  );
+}
+
+vec3 calculateClearcoatContribution(
+  PBRInfo pbrInfo,
+  vec3 lightColor,
+  vec3 clearcoatNormal,
+  float clearcoatFactor,
+  float clearcoatRoughness
+) {
+  if (clearcoatFactor <= 0.0) {
+    return vec3(0.0);
+  }
+
+  PBRInfo clearcoatPBRInfo = createClearcoatPBRInfo(pbrInfo, clearcoatNormal, clearcoatRoughness);
+  return calculateFinalColor(clearcoatPBRInfo, lightColor) * clearcoatFactor;
+}
+
+#ifdef USE_IBL
+vec3 calculateClearcoatIBLContribution(
+  PBRInfo pbrInfo,
+  vec3 clearcoatNormal,
+  vec3 reflection,
+  float clearcoatFactor,
+  float clearcoatRoughness
+) {
+  if (clearcoatFactor <= 0.0) {
+    return vec3(0.0);
+  }
+
+  PBRInfo clearcoatPBRInfo = createClearcoatPBRInfo(pbrInfo, clearcoatNormal, clearcoatRoughness);
+  return getIBLContribution(clearcoatPBRInfo, clearcoatNormal, reflection) * clearcoatFactor;
+}
+#endif
+
+vec3 calculateSheenContribution(
+  PBRInfo pbrInfo,
+  vec3 lightColor,
+  vec3 sheenColor,
+  float sheenRoughness
+) {
+  if (maxComponent(sheenColor) <= 0.0) {
+    return vec3(0.0);
+  }
+
+  float sheenFresnel = pow(clamp(1.0 - pbrInfo.VdotH, 0.0, 1.0), 5.0);
+  float sheenVisibility = mix(1.0, pbrInfo.NdotL * pbrInfo.NdotV, sheenRoughness);
+  return pbrInfo.NdotL *
+    lightColor *
+    sheenColor *
+    (0.25 + 0.75 * sheenFresnel) *
+    sheenVisibility *
+    (1.0 - pbrInfo.metalness);
+}
+
+float calculateAnisotropyBoost(
+  PBRInfo pbrInfo,
+  vec3 anisotropyTangent,
+  float anisotropyStrength
+) {
+  if (anisotropyStrength <= 0.0) {
+    return 1.0;
+  }
+
+  vec3 anisotropyBitangent = normalize(cross(pbrInfo.n, anisotropyTangent));
+  float bitangentViewAlignment = abs(dot(pbrInfo.v, anisotropyBitangent));
+  return mix(1.0, 0.65 + 0.7 * bitangentViewAlignment, anisotropyStrength);
+}
+
+vec3 calculateMaterialLightColor(
+  PBRInfo pbrInfo,
+  vec3 lightColor,
+  vec3 clearcoatNormal,
+  float clearcoatFactor,
+  float clearcoatRoughness,
+  vec3 sheenColor,
+  float sheenRoughness,
+  vec3 anisotropyTangent,
+  float anisotropyStrength
+) {
+  float anisotropyBoost = calculateAnisotropyBoost(pbrInfo, anisotropyTangent, anisotropyStrength);
+  vec3 color = calculateFinalColor(pbrInfo, lightColor) * anisotropyBoost;
+  color += calculateClearcoatContribution(
+    pbrInfo,
+    lightColor,
+    clearcoatNormal,
+    clearcoatFactor,
+    clearcoatRoughness
+  );
+  color += calculateSheenContribution(pbrInfo, lightColor, sheenColor, sheenRoughness);
+  return color;
+}
+
 void PBRInfo_setAmbientLight(inout PBRInfo pbrInfo) {
   pbrInfo.NdotL = 1.0;
   pbrInfo.NdotH = 0.0;
@@ -17074,6 +17914,11 @@ void PBRInfo_setPointLight(inout PBRInfo pbrInfo, PointLight pointLight) {
   PBRInfo_setDirectionalLight(pbrInfo, light_direction);
 }
 
+void PBRInfo_setSpotLight(inout PBRInfo pbrInfo, SpotLight spotLight) {
+  vec3 light_direction = normalize(spotLight.position - pbr_vPosition);
+  PBRInfo_setDirectionalLight(pbrInfo, light_direction);
+}
+
 vec3 calculateFinalColor(PBRInfo pbrInfo, vec3 lightColor) {
   // Calculate the shading terms for the microfacet specular shading model
   vec3 F = specularReflection(pbrInfo);
@@ -17089,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
@@ -17104,6 +18001,8 @@ vec4 pbr_filterColor(vec4 colorUnused)
 
   vec3 color = vec3(0, 0, 0);
 
+  float transmission = 0.0;
+
   if(pbrMaterial.unlit){
     color.rgb = baseColor.rgb;
   }
@@ -17116,20 +18015,258 @@ 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);
+    perceptualRoughness = clamp(perceptualRoughness, c_MinRoughness, 1.0);
+    metallic = clamp(metallic, 0.0, 1.0);
+    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
+    bool useExtendedPBR =
+      pbrMaterial.specularColorMapEnabled ||
+      pbrMaterial.specularIntensityMapEnabled ||
+      abs(pbrMaterial.specularIntensityFactor - 1.0) > 0.0001 ||
+      maxComponent(abs(pbrMaterial.specularColorFactor - vec3(1.0))) > 0.0001 ||
+      abs(pbrMaterial.ior - 1.5) > 0.0001 ||
+      pbrMaterial.transmissionMapEnabled ||
+      pbrMaterial.transmissionFactor > 0.0001 ||
+      pbrMaterial.clearcoatMapEnabled ||
+      pbrMaterial.clearcoatRoughnessMapEnabled ||
+      pbrMaterial.clearcoatFactor > 0.0001 ||
+      pbrMaterial.clearcoatRoughnessFactor > 0.0001 ||
+      pbrMaterial.sheenColorMapEnabled ||
+      pbrMaterial.sheenRoughnessMapEnabled ||
+      maxComponent(pbrMaterial.sheenColorFactor) > 0.0001 ||
+      pbrMaterial.sheenRoughnessFactor > 0.0001 ||
+      pbrMaterial.iridescenceMapEnabled ||
+      pbrMaterial.iridescenceFactor > 0.0001 ||
+      abs(pbrMaterial.iridescenceIor - 1.3) > 0.0001 ||
+      abs(pbrMaterial.iridescenceThicknessRange.x - 100.0) > 0.0001 ||
+      abs(pbrMaterial.iridescenceThicknessRange.y - 400.0) > 0.0001 ||
+      pbrMaterial.anisotropyMapEnabled ||
+      pbrMaterial.anisotropyStrength > 0.0001 ||
+      abs(pbrMaterial.anisotropyRotation) > 0.0001 ||
+      length(pbrMaterial.anisotropyDirection - vec2(1.0, 0.0)) > 0.0001;
+#else
+    bool useExtendedPBR = false;
+#endif
+
+    if (!useExtendedPBR) {
+      // Keep the baseline metallic-roughness implementation byte-for-byte equivalent in behavior.
+      float alphaRoughness = perceptualRoughness * perceptualRoughness;
+
+      vec3 f0 = vec3(0.04);
+      vec3 diffuseColor = baseColor.rgb * (vec3(1.0) - f0);
+      diffuseColor *= 1.0 - metallic;
+      vec3 specularColor = mix(f0, baseColor.rgb, metallic);
+
+      float reflectance = max(max(specularColor.r, specularColor.g), specularColor.b);
+      float reflectance90 = clamp(reflectance * 25.0, 0.0, 1.0);
+      vec3 specularEnvironmentR0 = specularColor.rgb;
+      vec3 specularEnvironmentR90 = vec3(1.0, 1.0, 1.0) * reflectance90;
+      vec3 reflection = -normalize(reflect(v, n));
+
+      PBRInfo pbrInfo = PBRInfo(
+        0.0, // NdotL
+        NdotV,
+        0.0, // NdotH
+        0.0, // LdotH
+        0.0, // VdotH
+        perceptualRoughness,
+        metallic,
+        specularEnvironmentR0,
+        specularEnvironmentR90,
+        alphaRoughness,
+        diffuseColor,
+        specularColor,
+        n,
+        v
+      );
+
+#ifdef USE_LIGHTS
+      PBRInfo_setAmbientLight(pbrInfo);
+      color += calculateFinalColor(pbrInfo, lighting.ambientColor);
+
+      for(int i = 0; i < lighting.directionalLightCount; i++) {
+        if (i < lighting.directionalLightCount) {
+          PBRInfo_setDirectionalLight(pbrInfo, lighting_getDirectionalLight(i).direction);
+          color += calculateFinalColor(pbrInfo, lighting_getDirectionalLight(i).color);
+        }
+      }
+
+      for(int i = 0; i < lighting.pointLightCount; i++) {
+        if (i < lighting.pointLightCount) {
+          PBRInfo_setPointLight(pbrInfo, lighting_getPointLight(i));
+          float attenuation = getPointLightAttenuation(lighting_getPointLight(i), distance(lighting_getPointLight(i).position, pbr_vPosition));
+          color += calculateFinalColor(pbrInfo, lighting_getPointLight(i).color / attenuation);
+        }
+      }
+
+      for(int i = 0; i < lighting.spotLightCount; i++) {
+        if (i < lighting.spotLightCount) {
+          PBRInfo_setSpotLight(pbrInfo, lighting_getSpotLight(i));
+          float attenuation = getSpotLightAttenuation(lighting_getSpotLight(i), pbr_vPosition);
+          color += calculateFinalColor(pbrInfo, lighting_getSpotLight(i).color / attenuation);
+        }
+      }
+#endif
+
+#ifdef USE_IBL
+      if (pbrMaterial.IBLenabled) {
+        color += getIBLContribution(pbrInfo, n, reflection);
+      }
+#endif
+
+#ifdef HAS_OCCLUSIONMAP
+      if (pbrMaterial.occlusionMapEnabled) {
+        float ao = texture(pbr_occlusionSampler, occlusionUV).r;
+        color = mix(color, color * ao, pbrMaterial.occlusionStrength);
+      }
+#endif
+
+      vec3 emissive = pbrMaterial.emissiveFactor;
+#ifdef HAS_EMISSIVEMAP
+      if (pbrMaterial.emissiveMapEnabled) {
+        emissive *= SRGBtoLINEAR(texture(pbr_emissiveSampler, emissiveUV)).rgb;
+      }
+#endif
+      color += emissive * pbrMaterial.emissiveStrength;
+
+#ifdef PBR_DEBUG
+      color = mix(color, baseColor.rgb, pbrMaterial.scaleDiffBaseMR.y);
+      color = mix(color, vec3(metallic), pbrMaterial.scaleDiffBaseMR.z);
+      color = mix(color, vec3(perceptualRoughness), pbrMaterial.scaleDiffBaseMR.w);
+#endif
+
+      return vec4(pow(color, vec3(1.0 / 2.2)), baseColor.a);
+    }
+
+    float specularIntensity = pbrMaterial.specularIntensityFactor;
+#ifdef HAS_SPECULARINTENSITYMAP
+    if (pbrMaterial.specularIntensityMapEnabled) {
+      specularIntensity *= texture(pbr_specularIntensitySampler, specularIntensityUV).a;
+    }
+#endif
+
+    vec3 specularFactor = pbrMaterial.specularColorFactor;
+#ifdef HAS_SPECULARCOLORMAP
+    if (pbrMaterial.specularColorMapEnabled) {
+      specularFactor *= SRGBtoLINEAR(texture(pbr_specularColorSampler, specularColorUV)).rgb;
+    }
+#endif
+
+    transmission = pbrMaterial.transmissionFactor;
+#ifdef HAS_TRANSMISSIONMAP
+    if (pbrMaterial.transmissionMapEnabled) {
+      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, thicknessUV).g;
+#endif
+
+    float clearcoatFactor = pbrMaterial.clearcoatFactor;
+    float clearcoatRoughness = pbrMaterial.clearcoatRoughnessFactor;
+#ifdef HAS_CLEARCOATMAP
+    if (pbrMaterial.clearcoatMapEnabled) {
+      clearcoatFactor *= texture(pbr_clearcoatSampler, clearcoatUV).r;
+    }
+#endif
+#ifdef HAS_CLEARCOATROUGHNESSMAP
+    if (pbrMaterial.clearcoatRoughnessMapEnabled) {
+      clearcoatRoughness *= texture(pbr_clearcoatRoughnessSampler, clearcoatRoughnessUV).g;
+    }
+#endif
+    clearcoatFactor = clamp(clearcoatFactor, 0.0, 1.0);
+    clearcoatRoughness = clamp(clearcoatRoughness, c_MinRoughness, 1.0);
+    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, sheenColorUV)).rgb;
+    }
+#endif
+#ifdef HAS_SHEENROUGHNESSMAP
+    if (pbrMaterial.sheenRoughnessMapEnabled) {
+      sheenRoughness *= texture(pbr_sheenRoughnessSampler, sheenRoughnessUV).a;
+    }
+#endif
+    sheenRoughness = clamp(sheenRoughness, c_MinRoughness, 1.0);
+
+    float iridescence = pbrMaterial.iridescenceFactor;
+#ifdef HAS_IRIDESCENCEMAP
+    if (pbrMaterial.iridescenceMapEnabled) {
+      iridescence *= texture(pbr_iridescenceSampler, iridescenceUV).r;
+    }
+#endif
+    iridescence = clamp(iridescence, 0.0, 1.0);
+    float iridescenceThickness = mix(
+      pbrMaterial.iridescenceThicknessRange.x,
+      pbrMaterial.iridescenceThicknessRange.y,
+      0.5
+    );
+#ifdef HAS_IRIDESCENCETHICKNESSMAP
+    iridescenceThickness = mix(
+      pbrMaterial.iridescenceThicknessRange.x,
+      pbrMaterial.iridescenceThicknessRange.y,
+      texture(pbr_iridescenceThicknessSampler, iridescenceThicknessUV).g
+    );
+#endif
+
+    float anisotropyStrength = clamp(pbrMaterial.anisotropyStrength, 0.0, 1.0);
+    vec2 anisotropyDirection = normalizeDirection(pbrMaterial.anisotropyDirection);
+#ifdef HAS_ANISOTROPYMAP
+    if (pbrMaterial.anisotropyMapEnabled) {
+      vec3 anisotropySample = texture(pbr_anisotropySampler, anisotropyUV).rgb;
+      anisotropyStrength *= anisotropySample.b;
+      vec2 mappedDirection = anisotropySample.rg * 2.0 - 1.0;
+      if (length(mappedDirection) > 0.0001) {
+        anisotropyDirection = normalize(mappedDirection);
+      }
+    }
+#endif
+    anisotropyDirection = rotateDirection(anisotropyDirection, pbrMaterial.anisotropyRotation);
+    vec3 anisotropyTangent = normalize(tbn[0] * anisotropyDirection.x + tbn[1] * anisotropyDirection.y);
+    if (length(anisotropyTangent) < 0.0001) {
+      anisotropyTangent = normalize(tbn[0]);
+    }
+    float anisotropyViewAlignment = abs(dot(v, anisotropyTangent));
+    perceptualRoughness = mix(
+      perceptualRoughness,
+      clamp(perceptualRoughness * (1.0 - 0.6 * anisotropyViewAlignment), c_MinRoughness, 1.0),
+      anisotropyStrength
+    );
+
     // Roughness is authored as perceptual roughness; as is convention,
     // convert to material roughness by squaring the perceptual roughness [2].
     float alphaRoughness = perceptualRoughness * perceptualRoughness;
 
-    vec3 f0 = vec3(0.04);
-    vec3 diffuseColor = baseColor.rgb * (vec3(1.0) - f0);
-    diffuseColor *= 1.0 - metallic;
-    vec3 specularColor = mix(f0, baseColor.rgb, metallic);
+    float dielectricF0 = getDielectricF0(pbrMaterial.ior);
+    vec3 dielectricSpecularF0 = min(
+      vec3(dielectricF0) * specularFactor * specularIntensity,
+      vec3(1.0)
+    );
+    vec3 iridescenceTint = getIridescenceTint(iridescence, iridescenceThickness, NdotV);
+    dielectricSpecularF0 = mix(
+      dielectricSpecularF0,
+      dielectricSpecularF0 * iridescenceTint,
+      iridescence
+    );
+    vec3 diffuseColor = baseColor.rgb * (vec3(1.0) - dielectricSpecularF0);
+    diffuseColor *= (1.0 - metallic) * (1.0 - transmission);
+    vec3 specularColor = mix(dielectricSpecularF0, baseColor.rgb, metallic);
+
+    float baseLayerEnergy = 1.0 - clearcoatFactor * 0.25;
+    diffuseColor *= baseLayerEnergy;
+    specularColor *= baseLayerEnergy;
 
     // Compute reflectance.
     float reflectance = max(max(specularColor.r, specularColor.g), specularColor.b);
@@ -17141,11 +18278,6 @@ vec4 pbr_filterColor(vec4 colorUnused)
     float reflectance90 = clamp(reflectance * 25.0, 0.0, 1.0);
     vec3 specularEnvironmentR0 = specularColor.rgb;
     vec3 specularEnvironmentR90 = vec3(1.0, 1.0, 1.0) * reflectance90;
-
-    vec3 n = getNormal();                          // 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);
     vec3 reflection = -normalize(reflect(v, n));
 
     PBRInfo pbrInfo = PBRInfo(
@@ -17169,13 +18301,33 @@ vec4 pbr_filterColor(vec4 colorUnused)
 #ifdef USE_LIGHTS
     // Apply ambient light
     PBRInfo_setAmbientLight(pbrInfo);
-    color += calculateFinalColor(pbrInfo, lighting.ambientColor);
+    color += calculateMaterialLightColor(
+      pbrInfo,
+      lighting.ambientColor,
+      clearcoatNormal,
+      clearcoatFactor,
+      clearcoatRoughness,
+      sheenColor,
+      sheenRoughness,
+      anisotropyTangent,
+      anisotropyStrength
+    );
 
     // Apply directional light
     for(int i = 0; i < lighting.directionalLightCount; i++) {
       if (i < lighting.directionalLightCount) {
         PBRInfo_setDirectionalLight(pbrInfo, lighting_getDirectionalLight(i).direction);
-        color += calculateFinalColor(pbrInfo, lighting_getDirectionalLight(i).color);
+        color += calculateMaterialLightColor(
+          pbrInfo,
+          lighting_getDirectionalLight(i).color,
+          clearcoatNormal,
+          clearcoatFactor,
+          clearcoatRoughness,
+          sheenColor,
+          sheenRoughness,
+          anisotropyTangent,
+          anisotropyStrength
+        );
       }
     }
 
@@ -17184,7 +18336,35 @@ vec4 pbr_filterColor(vec4 colorUnused)
       if (i < lighting.pointLightCount) {
         PBRInfo_setPointLight(pbrInfo, lighting_getPointLight(i));
         float attenuation = getPointLightAttenuation(lighting_getPointLight(i), distance(lighting_getPointLight(i).position, pbr_vPosition));
-        color += calculateFinalColor(pbrInfo, lighting_getPointLight(i).color / attenuation);
+        color += calculateMaterialLightColor(
+          pbrInfo,
+          lighting_getPointLight(i).color / attenuation,
+          clearcoatNormal,
+          clearcoatFactor,
+          clearcoatRoughness,
+          sheenColor,
+          sheenRoughness,
+          anisotropyTangent,
+          anisotropyStrength
+        );
+      }
+    }
+
+    for(int i = 0; i < lighting.spotLightCount; i++) {
+      if (i < lighting.spotLightCount) {
+        PBRInfo_setSpotLight(pbrInfo, lighting_getSpotLight(i));
+        float attenuation = getSpotLightAttenuation(lighting_getSpotLight(i), pbr_vPosition);
+        color += calculateMaterialLightColor(
+          pbrInfo,
+          lighting_getSpotLight(i).color / attenuation,
+          clearcoatNormal,
+          clearcoatFactor,
+          clearcoatRoughness,
+          sheenColor,
+          sheenRoughness,
+          anisotropyTangent,
+          anisotropyStrength
+        );
       }
     }
 #endif
@@ -17192,24 +18372,38 @@ vec4 pbr_filterColor(vec4 colorUnused)
     // Calculate lighting contribution from image based lighting source (IBL)
 #ifdef USE_IBL
     if (pbrMaterial.IBLenabled) {
-      color += getIBLContribution(pbrInfo, n, reflection);
+      color += getIBLContribution(pbrInfo, n, reflection) *
+        calculateAnisotropyBoost(pbrInfo, anisotropyTangent, anisotropyStrength);
+      color += calculateClearcoatIBLContribution(
+        pbrInfo,
+        clearcoatNormal,
+        -normalize(reflect(v, clearcoatNormal)),
+        clearcoatFactor,
+        clearcoatRoughness
+      );
+      color += sheenColor * pbrMaterial.scaleIBLAmbient.x * (1.0 - sheenRoughness) * 0.25;
     }
 #endif
 
  // 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
 
+    vec3 emissive = pbrMaterial.emissiveFactor;
 #ifdef HAS_EMISSIVEMAP
     if (pbrMaterial.emissiveMapEnabled) {
-      vec3 emissive = SRGBtoLINEAR(texture(pbr_emissiveSampler, pbr_vUV)).rgb * pbrMaterial.emissiveFactor;
-      color += emissive;
+      emissive *= SRGBtoLINEAR(texture(pbr_emissiveSampler, emissiveUV)).rgb;
     }
 #endif
+    color += emissive * pbrMaterial.emissiveStrength;
+
+    if (transmission > 0.0) {
+      color = mix(color, color * getVolumeAttenuation(thickness), transmission);
+    }
 
     // This section uses mix to override final color for reference app visualization
     // of various parameters in the lighting equation.
@@ -17229,7 +18423,8 @@ vec4 pbr_filterColor(vec4 colorUnused)
 
   }
 
-  return vec4(pow(color,vec3(1.0/2.2)), baseColor.a);
+  float alpha = clamp(baseColor.a * (1.0 - transmission), 0.0, 1.0);
+  return vec4(pow(color,vec3(1.0/2.2)), alpha);
 }
 `
   );
@@ -17239,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;
@@ -17256,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);
@@ -17269,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
 }
 
@@ -17295,6 +18498,42 @@ struct pbrMaterialUniforms {
   
   alphaCutoffEnabled: i32,
   alphaCutoff: f32, // #ifdef ALPHA_CUTOFF
+
+  specularColorFactor: vec3f,
+  specularIntensityFactor: f32,
+  specularColorMapEnabled: i32,
+  specularIntensityMapEnabled: i32,
+
+  ior: f32,
+
+  transmissionFactor: f32,
+  transmissionMapEnabled: i32,
+
+  thicknessFactor: f32,
+  attenuationDistance: f32,
+  attenuationColor: vec3f,
+
+  clearcoatFactor: f32,
+  clearcoatRoughnessFactor: f32,
+  clearcoatMapEnabled: i32,
+  clearcoatRoughnessMapEnabled: i32,
+
+  sheenColorFactor: vec3f,
+  sheenRoughnessFactor: f32,
+  sheenColorMapEnabled: i32,
+  sheenRoughnessMapEnabled: i32,
+
+  iridescenceFactor: f32,
+  iridescenceIor: f32,
+  iridescenceThicknessRange: vec2f,
+  iridescenceMapEnabled: i32,
+
+  anisotropyStrength: f32,
+  anisotropyRotation: f32,
+  anisotropyDirection: vec2f,
+  anisotropyMapEnabled: i32,
+
+  emissiveStrength: f32,
   
   // IBL
   IBLenabled: i32,
@@ -17305,40 +18544,114 @@ 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,
 }
 
-@binding(2) @group(0) var<uniform> pbrMaterial : pbrMaterialUniforms;
+@group(3) @binding(auto) var<uniform> pbrMaterial : pbrMaterialUniforms;
 
 // Samplers
 #ifdef HAS_BASECOLORMAP
-@binding(3) @group(0) var pbr_baseColorSampler: texture_2d<f32>;
-@binding(4) @group(0) var pbr_baseColorSamplerSampler: sampler;
+@group(3) @binding(auto) var pbr_baseColorSampler: texture_2d<f32>;
+@group(3) @binding(auto) var pbr_baseColorSamplerSampler: sampler;
 #endif
 #ifdef HAS_NORMALMAP
-@binding(5) @group(0) var pbr_normalSampler: texture_2d<f32>;
-@binding(6) @group(0) var pbr_normalSamplerSampler: sampler;
+@group(3) @binding(auto) var pbr_normalSampler: texture_2d<f32>;
+@group(3) @binding(auto) var pbr_normalSamplerSampler: sampler;
 #endif
 #ifdef HAS_EMISSIVEMAP
-@binding(7) @group(0) var pbr_emissiveSampler: texture_2d<f32>;
-@binding(8) @group(0) var pbr_emissiveSamplerSampler: sampler;
+@group(3) @binding(auto) var pbr_emissiveSampler: texture_2d<f32>;
+@group(3) @binding(auto) var pbr_emissiveSamplerSampler: sampler;
 #endif
 #ifdef HAS_METALROUGHNESSMAP
-@binding(9) @group(0) var pbr_metallicRoughnessSampler: texture_2d<f32>;
-@binding(10) @group(0) var pbr_metallicRoughnessSamplerSampler: sampler;
+@group(3) @binding(auto) var pbr_metallicRoughnessSampler: texture_2d<f32>;
+@group(3) @binding(auto) var pbr_metallicRoughnessSamplerSampler: sampler;
 #endif
 #ifdef HAS_OCCLUSIONMAP
-@binding(11) @group(0) var pbr_occlusionSampler: texture_2d<f32>;
-@binding(12) @group(0) var pbr_occlusionSamplerSampler: sampler;
+@group(3) @binding(auto) var pbr_occlusionSampler: texture_2d<f32>;
+@group(3) @binding(auto) var pbr_occlusionSamplerSampler: sampler;
 #endif
-#ifdef USE_IBL
-@binding(13) @group(0) var pbr_diffuseEnvSampler: texture_cube<f32>;
-@binding(14) @group(0) var pbr_diffuseEnvSamplerSampler: sampler;
-@binding(15) @group(0) var pbr_specularEnvSampler: texture_cube<f32>;
-@binding(16) @group(0) var pbr_specularEnvSamplerSampler: sampler;
-@binding(17) @group(0) var pbr_BrdfLUT: texture_2d<f32>;
-@binding(18) @group(0) var pbr_BrdfLUTSampler: sampler;
+#ifdef HAS_SPECULARCOLORMAP
+@group(3) @binding(auto) var pbr_specularColorSampler: texture_2d<f32>;
+@group(3) @binding(auto) var pbr_specularColorSamplerSampler: sampler;
+#endif
+#ifdef HAS_SPECULARINTENSITYMAP
+@group(3) @binding(auto) var pbr_specularIntensitySampler: texture_2d<f32>;
+@group(3) @binding(auto) var pbr_specularIntensitySamplerSampler: sampler;
+#endif
+#ifdef HAS_TRANSMISSIONMAP
+@group(3) @binding(auto) var pbr_transmissionSampler: texture_2d<f32>;
+@group(3) @binding(auto) var pbr_transmissionSamplerSampler: sampler;
+#endif
+#ifdef HAS_THICKNESSMAP
+@group(3) @binding(auto) var pbr_thicknessSampler: texture_2d<f32>;
+@group(3) @binding(auto) var pbr_thicknessSamplerSampler: sampler;
+#endif
+#ifdef HAS_CLEARCOATMAP
+@group(3) @binding(auto) var pbr_clearcoatSampler: texture_2d<f32>;
+@group(3) @binding(auto) var pbr_clearcoatSamplerSampler: sampler;
+#endif
+#ifdef HAS_CLEARCOATROUGHNESSMAP
+@group(3) @binding(auto) var pbr_clearcoatRoughnessSampler: texture_2d<f32>;
+@group(3) @binding(auto) var pbr_clearcoatRoughnessSamplerSampler: sampler;
+#endif
+#ifdef HAS_CLEARCOATNORMALMAP
+@group(3) @binding(auto) var pbr_clearcoatNormalSampler: texture_2d<f32>;
+@group(3) @binding(auto) var pbr_clearcoatNormalSamplerSampler: sampler;
+#endif
+#ifdef HAS_SHEENCOLORMAP
+@group(3) @binding(auto) var pbr_sheenColorSampler: texture_2d<f32>;
+@group(3) @binding(auto) var pbr_sheenColorSamplerSampler: sampler;
+#endif
+#ifdef HAS_SHEENROUGHNESSMAP
+@group(3) @binding(auto) var pbr_sheenRoughnessSampler: texture_2d<f32>;
+@group(3) @binding(auto) var pbr_sheenRoughnessSamplerSampler: sampler;
+#endif
+#ifdef HAS_IRIDESCENCEMAP
+@group(3) @binding(auto) var pbr_iridescenceSampler: texture_2d<f32>;
+@group(3) @binding(auto) var pbr_iridescenceSamplerSampler: sampler;
+#endif
+#ifdef HAS_IRIDESCENCETHICKNESSMAP
+@group(3) @binding(auto) var pbr_iridescenceThicknessSampler: texture_2d<f32>;
+@group(3) @binding(auto) var pbr_iridescenceThicknessSamplerSampler: sampler;
+#endif
+#ifdef HAS_ANISOTROPYMAP
+@group(3) @binding(auto) var pbr_anisotropySampler: texture_2d<f32>;
+@group(3) @binding(auto) var pbr_anisotropySamplerSampler: sampler;
 #endif
-
 // Encapsulate the various inputs used by the various functions in the shading equation
 // We store values in this struct to simplify the integration of alternative implementations
 // of the shading terms, outlined in the Readme.MD Appendix.
@@ -17379,15 +18692,22 @@ fn SRGBtoLINEAR(srgbIn: vec4f ) -> vec4f
   return vec4f(linOut, srgbIn.w);
 }
 
-// Find the normal for this fragment, pulling either from a predefined normal map
-// or from the interpolated mesh normal and tangent attributes.
-fn getNormal() -> vec3f
+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(uv: vec2f) -> mat3x3f
 {
-  // Retrieve the tangent space matrix
   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);
@@ -17401,16 +18721,55 @@ fn getNormal() -> vec3f
   tbn = fragmentInputs.pbr_vTBN;
 #endif
 
+  return tbn;
+}
+
+// Find the normal for this fragment, pulling either from a predefined normal map
+// or from the interpolated mesh normal and tangent attributes.
+fn getMappedNormal(
+  normalSampler: texture_2d<f32>,
+  normalSamplerBinding: sampler,
+  tbn: mat3x3f,
+  normalScale: f32,
+  uv: vec2f
+) -> vec3f
+{
+  let n = textureSample(normalSampler, normalSamplerBinding, uv).rgb;
+  return normalize(tbn * ((2.0 * n - 1.0) * vec3f(normalScale, normalScale, 1.0)));
+}
+
+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);
 #ifdef HAS_NORMALMAP
-  n = textureSample(pbr_normalSampler, pbr_normalSamplerSampler, fragmentInputs.pbr_vUV).rgb;
-  n = normalize(tbn * ((2.0 * n - 1.0) * vec3f(pbrMaterial.normalScale, pbrMaterial.normalScale, 1.0)));
+  n = getMappedNormal(
+    pbr_normalSampler,
+    pbr_normalSamplerSampler,
+    tbn,
+    pbrMaterial.normalScale,
+    uv
+  );
 #endif
 
   return n;
 }
 
+fn getClearcoatNormal(tbn: mat3x3f, baseNormal: vec3f, uv: vec2f) -> vec3f
+{
+#ifdef HAS_CLEARCOATNORMALMAP
+  return getMappedNormal(
+    pbr_clearcoatNormalSampler,
+    pbr_clearcoatNormalSamplerSampler,
+    tbn,
+    1.0,
+    uv
+  );
+#else
+  return baseNormal;
+#endif
+}
+
 // Calculation of the lighting contribution from an optional Image Based Light source.
 // Precomputed Environment Maps are required uniform inputs and are computed as outlined in [1].
 // See our README.md on Environment Maps [3] for additional discussion.
@@ -17421,17 +18780,25 @@ fn getIBLContribution(pbrInfo: PBRInfo, n: vec3f, reflection: vec3f) -> vec3f
   let lod: f32 = pbrInfo.perceptualRoughness * mipCount;
   // retrieve a scale and bias to F0. See [1], Figure 3
   let brdf = SRGBtoLINEAR(
-    textureSample(
-      pbr_BrdfLUT,
-      pbr_BrdfLUTSampler,
-      vec2f(pbrInfo.NdotV, 1.0 - pbrInfo.perceptualRoughness)
+    textureSampleLevel(
+      pbr_brdfLUT,
+      pbr_brdfLUTSampler,
+      vec2f(pbrInfo.NdotV, 1.0 - pbrInfo.perceptualRoughness),
+      0.0
     )
   ).rgb;
   let diffuseLight =
-    SRGBtoLINEAR(textureSample(pbr_diffuseEnvSampler, pbr_diffuseEnvSamplerSampler, n)).rgb;
-  let specularLightDefault =
-    SRGBtoLINEAR(textureSample(pbr_specularEnvSampler, pbr_specularEnvSamplerSampler, reflection)).rgb;
-  var specularLight = specularLightDefault;
+    SRGBtoLINEAR(
+      textureSampleLevel(pbr_diffuseEnvSampler, pbr_diffuseEnvSamplerSampler, n, 0.0)
+    ).rgb;
+  var specularLight = SRGBtoLINEAR(
+    textureSampleLevel(
+      pbr_specularEnvSampler,
+      pbr_specularEnvSamplerSampler,
+      reflection,
+      0.0
+    )
+  ).rgb;
 #ifdef USE_TEX_LOD
   specularLight = SRGBtoLINEAR(
     textureSampleLevel(
@@ -17492,6 +18859,172 @@ fn microfacetDistribution(pbrInfo: PBRInfo) -> f32 {
   return roughnessSq / (M_PI * f * f);
 }
 
+fn maxComponent(value: vec3f) -> f32 {
+  return max(max(value.r, value.g), value.b);
+}
+
+fn getDielectricF0(ior: f32) -> f32 {
+  let clampedIor = max(ior, 1.0);
+  let ratio = (clampedIor - 1.0) / (clampedIor + 1.0);
+  return ratio * ratio;
+}
+
+fn normalizeDirection(direction: vec2f) -> vec2f {
+  let directionLength = length(direction);
+  if (directionLength > 0.0001) {
+    return direction / directionLength;
+  }
+
+  return vec2f(1.0, 0.0);
+}
+
+fn rotateDirection(direction: vec2f, rotation: f32) -> vec2f {
+  let s = sin(rotation);
+  let c = cos(rotation);
+  return vec2f(direction.x * c - direction.y * s, direction.x * s + direction.y * c);
+}
+
+fn getIridescenceTint(iridescence: f32, thickness: f32, NdotV: f32) -> vec3f {
+  if (iridescence <= 0.0) {
+    return vec3f(1.0);
+  }
+
+  let phase = 0.015 * thickness * pbrMaterial.iridescenceIor + (1.0 - NdotV) * 6.0;
+  let thinFilmTint =
+    0.5 +
+    0.5 *
+    cos(vec3f(phase, phase + 2.0943951, phase + 4.1887902));
+  return mix(vec3f(1.0), thinFilmTint, iridescence);
+}
+
+fn getVolumeAttenuation(thickness: f32) -> vec3f {
+  if (thickness <= 0.0) {
+    return vec3f(1.0);
+  }
+
+  let attenuationCoefficient =
+    -log(max(pbrMaterial.attenuationColor, vec3f(0.0001))) /
+    max(pbrMaterial.attenuationDistance, 0.0001);
+  return exp(-attenuationCoefficient * thickness);
+}
+
+fn createClearcoatPBRInfo(
+  basePBRInfo: PBRInfo,
+  clearcoatNormal: vec3f,
+  clearcoatRoughness: f32
+) -> PBRInfo {
+  let perceptualRoughness = clamp(clearcoatRoughness, c_MinRoughness, 1.0);
+  let alphaRoughness = perceptualRoughness * perceptualRoughness;
+  let NdotV = clamp(abs(dot(clearcoatNormal, basePBRInfo.v)), 0.001, 1.0);
+
+  return PBRInfo(
+    basePBRInfo.NdotL,
+    NdotV,
+    basePBRInfo.NdotH,
+    basePBRInfo.LdotH,
+    basePBRInfo.VdotH,
+    perceptualRoughness,
+    0.0,
+    vec3f(0.04),
+    vec3f(1.0),
+    alphaRoughness,
+    vec3f(0.0),
+    vec3f(0.04),
+    clearcoatNormal,
+    basePBRInfo.v
+  );
+}
+
+fn calculateClearcoatContribution(
+  pbrInfo: PBRInfo,
+  lightColor: vec3f,
+  clearcoatNormal: vec3f,
+  clearcoatFactor: f32,
+  clearcoatRoughness: f32
+) -> vec3f {
+  if (clearcoatFactor <= 0.0) {
+    return vec3f(0.0);
+  }
+
+  let clearcoatPBRInfo = createClearcoatPBRInfo(pbrInfo, clearcoatNormal, clearcoatRoughness);
+  return calculateFinalColor(clearcoatPBRInfo, lightColor) * clearcoatFactor;
+}
+
+#ifdef USE_IBL
+fn calculateClearcoatIBLContribution(
+  pbrInfo: PBRInfo,
+  clearcoatNormal: vec3f,
+  reflection: vec3f,
+  clearcoatFactor: f32,
+  clearcoatRoughness: f32
+) -> vec3f {
+  if (clearcoatFactor <= 0.0) {
+    return vec3f(0.0);
+  }
+
+  let clearcoatPBRInfo = createClearcoatPBRInfo(pbrInfo, clearcoatNormal, clearcoatRoughness);
+  return getIBLContribution(clearcoatPBRInfo, clearcoatNormal, reflection) * clearcoatFactor;
+}
+#endif
+
+fn calculateSheenContribution(
+  pbrInfo: PBRInfo,
+  lightColor: vec3f,
+  sheenColor: vec3f,
+  sheenRoughness: f32
+) -> vec3f {
+  if (maxComponent(sheenColor) <= 0.0) {
+    return vec3f(0.0);
+  }
+
+  let sheenFresnel = pow(clamp(1.0 - pbrInfo.VdotH, 0.0, 1.0), 5.0);
+  let sheenVisibility = mix(1.0, pbrInfo.NdotL * pbrInfo.NdotV, sheenRoughness);
+  return pbrInfo.NdotL *
+    lightColor *
+    sheenColor *
+    (0.25 + 0.75 * sheenFresnel) *
+    sheenVisibility *
+    (1.0 - pbrInfo.metalness);
+}
+
+fn calculateAnisotropyBoost(
+  pbrInfo: PBRInfo,
+  anisotropyTangent: vec3f,
+  anisotropyStrength: f32
+) -> f32 {
+  if (anisotropyStrength <= 0.0) {
+    return 1.0;
+  }
+
+  let anisotropyBitangent = normalize(cross(pbrInfo.n, anisotropyTangent));
+  let bitangentViewAlignment = abs(dot(pbrInfo.v, anisotropyBitangent));
+  return mix(1.0, 0.65 + 0.7 * bitangentViewAlignment, anisotropyStrength);
+}
+
+fn calculateMaterialLightColor(
+  pbrInfo: PBRInfo,
+  lightColor: vec3f,
+  clearcoatNormal: vec3f,
+  clearcoatFactor: f32,
+  clearcoatRoughness: f32,
+  sheenColor: vec3f,
+  sheenRoughness: f32,
+  anisotropyTangent: vec3f,
+  anisotropyStrength: f32
+) -> vec3f {
+  let anisotropyBoost = calculateAnisotropyBoost(pbrInfo, anisotropyTangent, anisotropyStrength);
+  var color = calculateFinalColor(pbrInfo, lightColor) * anisotropyBoost;
+  color += calculateClearcoatContribution(
+    pbrInfo,
+    lightColor,
+    clearcoatNormal,
+    clearcoatFactor,
+    clearcoatRoughness
+  );
+  color += calculateSheenContribution(pbrInfo, lightColor, sheenColor, sheenRoughness);
+  return color;
+}
+
 fn PBRInfo_setAmbientLight(pbrInfo: ptr<function, PBRInfo>) {
   (*pbrInfo).NdotL = 1.0;
   (*pbrInfo).NdotH = 0.0;
@@ -17516,6 +19049,11 @@ fn PBRInfo_setPointLight(pbrInfo: ptr<function, PBRInfo>, pointLight: PointLight
   PBRInfo_setDirectionalLight(pbrInfo, light_direction);
 }
 
+fn PBRInfo_setSpotLight(pbrInfo: ptr<function, PBRInfo>, spotLight: SpotLight) {
+  let light_direction = normalize(spotLight.position - fragmentInputs.pbr_vPosition);
+  PBRInfo_setDirectionalLight(pbrInfo, light_direction);
+}
+
 fn calculateFinalColor(pbrInfo: PBRInfo, lightColor: vec3<f32>) -> vec3<f32> {
   // Calculate the shading terms for the microfacet specular shading model
   let F = specularReflection(pbrInfo);
@@ -17530,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
 
@@ -17545,6 +19134,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
   #endif
 
   var color = vec3<f32>(0.0, 0.0, 0.0);
+  var transmission = 0.0;
 
   if (pbrMaterial.unlit != 0u) {
     color = baseColor.rgb;
@@ -17560,21 +19150,314 @@ 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(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;
+    #ifdef USE_MATERIAL_EXTENSIONS
+    useExtendedPBR =
+      pbrMaterial.specularColorMapEnabled != 0 ||
+      pbrMaterial.specularIntensityMapEnabled != 0 ||
+      abs(pbrMaterial.specularIntensityFactor - 1.0) > 0.0001 ||
+      maxComponent(abs(pbrMaterial.specularColorFactor - vec3f(1.0))) > 0.0001 ||
+      abs(pbrMaterial.ior - 1.5) > 0.0001 ||
+      pbrMaterial.transmissionMapEnabled != 0 ||
+      pbrMaterial.transmissionFactor > 0.0001 ||
+      pbrMaterial.clearcoatMapEnabled != 0 ||
+      pbrMaterial.clearcoatRoughnessMapEnabled != 0 ||
+      pbrMaterial.clearcoatFactor > 0.0001 ||
+      pbrMaterial.clearcoatRoughnessFactor > 0.0001 ||
+      pbrMaterial.sheenColorMapEnabled != 0 ||
+      pbrMaterial.sheenRoughnessMapEnabled != 0 ||
+      maxComponent(pbrMaterial.sheenColorFactor) > 0.0001 ||
+      pbrMaterial.sheenRoughnessFactor > 0.0001 ||
+      pbrMaterial.iridescenceMapEnabled != 0 ||
+      pbrMaterial.iridescenceFactor > 0.0001 ||
+      abs(pbrMaterial.iridescenceIor - 1.3) > 0.0001 ||
+      abs(pbrMaterial.iridescenceThicknessRange.x - 100.0) > 0.0001 ||
+      abs(pbrMaterial.iridescenceThicknessRange.y - 400.0) > 0.0001 ||
+      pbrMaterial.anisotropyMapEnabled != 0 ||
+      pbrMaterial.anisotropyStrength > 0.0001 ||
+      abs(pbrMaterial.anisotropyRotation) > 0.0001 ||
+      length(pbrMaterial.anisotropyDirection - vec2f(1.0, 0.0)) > 0.0001;
+    #endif
+
+    if (!useExtendedPBR) {
+      let alphaRoughness = perceptualRoughness * perceptualRoughness;
+
+      let f0 = vec3<f32>(0.04);
+      var diffuseColor = baseColor.rgb * (vec3<f32>(1.0) - f0);
+      diffuseColor *= 1.0 - metallic;
+      let specularColor = mix(f0, baseColor.rgb, metallic);
+
+      let reflectance = max(max(specularColor.r, specularColor.g), specularColor.b);
+      let reflectance90 = clamp(reflectance * 25.0, 0.0, 1.0);
+      let specularEnvironmentR0 = specularColor;
+      let specularEnvironmentR90 = vec3<f32>(1.0, 1.0, 1.0) * reflectance90;
+      let reflection = -normalize(reflect(v, n));
+
+      var pbrInfo = PBRInfo(
+        0.0, // NdotL
+        NdotV,
+        0.0, // NdotH
+        0.0, // LdotH
+        0.0, // VdotH
+        perceptualRoughness,
+        metallic,
+        specularEnvironmentR0,
+        specularEnvironmentR90,
+        alphaRoughness,
+        diffuseColor,
+        specularColor,
+        n,
+        v
+      );
+
+      #ifdef USE_LIGHTS
+      PBRInfo_setAmbientLight(&pbrInfo);
+      color += calculateFinalColor(pbrInfo, lighting.ambientColor);
+
+      for (var i = 0; i < lighting.directionalLightCount; i++) {
+        if (i < lighting.directionalLightCount) {
+          PBRInfo_setDirectionalLight(&pbrInfo, lighting_getDirectionalLight(i).direction);
+          color += calculateFinalColor(pbrInfo, lighting_getDirectionalLight(i).color);
+        }
+      }
+
+      for (var i = 0; i < lighting.pointLightCount; i++) {
+        if (i < lighting.pointLightCount) {
+          PBRInfo_setPointLight(&pbrInfo, lighting_getPointLight(i));
+          let attenuation = getPointLightAttenuation(
+            lighting_getPointLight(i),
+            distance(lighting_getPointLight(i).position, fragmentInputs.pbr_vPosition)
+          );
+          color += calculateFinalColor(pbrInfo, lighting_getPointLight(i).color / attenuation);
+        }
+      }
+
+      for (var i = 0; i < lighting.spotLightCount; i++) {
+        if (i < lighting.spotLightCount) {
+          PBRInfo_setSpotLight(&pbrInfo, lighting_getSpotLight(i));
+          let attenuation = getSpotLightAttenuation(
+            lighting_getSpotLight(i),
+            fragmentInputs.pbr_vPosition
+          );
+          color += calculateFinalColor(pbrInfo, lighting_getSpotLight(i).color / attenuation);
+        }
+      }
+      #endif
+
+      #ifdef USE_IBL
+      if (pbrMaterial.IBLenabled != 0) {
+        color += getIBLContribution(pbrInfo, n, reflection);
+      }
+      #endif
+
+      #ifdef HAS_OCCLUSIONMAP
+      if (pbrMaterial.occlusionMapEnabled != 0) {
+        let ao = textureSample(pbr_occlusionSampler, pbr_occlusionSamplerSampler, occlusionUV).r;
+        color = mix(color, color * ao, pbrMaterial.occlusionStrength);
+      }
+      #endif
+
+      var emissive = pbrMaterial.emissiveFactor;
+      #ifdef HAS_EMISSIVEMAP
+      if (pbrMaterial.emissiveMapEnabled != 0u) {
+        emissive *= SRGBtoLINEAR(
+          textureSample(pbr_emissiveSampler, pbr_emissiveSamplerSampler, emissiveUV)
+        ).rgb;
+      }
+      #endif
+      color += emissive * pbrMaterial.emissiveStrength;
+
+      #ifdef PBR_DEBUG
+      color = mix(color, baseColor.rgb, pbrMaterial.scaleDiffBaseMR.y);
+      color = mix(color, vec3<f32>(metallic), pbrMaterial.scaleDiffBaseMR.z);
+      color = mix(color, vec3<f32>(perceptualRoughness), pbrMaterial.scaleDiffBaseMR.w);
+      #endif
+
+      return vec4<f32>(pow(color, vec3<f32>(1.0 / 2.2)), baseColor.a);
+    }
+
+    var specularIntensity = pbrMaterial.specularIntensityFactor;
+    #ifdef HAS_SPECULARINTENSITYMAP
+    if (pbrMaterial.specularIntensityMapEnabled != 0) {
+      specularIntensity *= textureSample(
+        pbr_specularIntensitySampler,
+        pbr_specularIntensitySamplerSampler,
+        specularIntensityUV
+      ).a;
+    }
+    #endif
+
+    var specularFactor = pbrMaterial.specularColorFactor;
+    #ifdef HAS_SPECULARCOLORMAP
+    if (pbrMaterial.specularColorMapEnabled != 0) {
+      specularFactor *= SRGBtoLINEAR(
+        textureSample(
+          pbr_specularColorSampler,
+          pbr_specularColorSamplerSampler,
+          specularColorUV
+        )
+      ).rgb;
+    }
+    #endif
+
+    transmission = pbrMaterial.transmissionFactor;
+    #ifdef HAS_TRANSMISSIONMAP
+    if (pbrMaterial.transmissionMapEnabled != 0) {
+      transmission *= textureSample(
+        pbr_transmissionSampler,
+        pbr_transmissionSamplerSampler,
+        transmissionUV
+      ).r;
+    }
+    #endif
+    transmission = clamp(transmission * (1.0 - metallic), 0.0, 1.0);
+    var thickness = max(pbrMaterial.thicknessFactor, 0.0);
+    #ifdef HAS_THICKNESSMAP
+    thickness *= textureSample(
+      pbr_thicknessSampler,
+      pbr_thicknessSamplerSampler,
+      thicknessUV
+    ).g;
+    #endif
+
+    var clearcoatFactor = pbrMaterial.clearcoatFactor;
+    var clearcoatRoughness = pbrMaterial.clearcoatRoughnessFactor;
+    #ifdef HAS_CLEARCOATMAP
+    if (pbrMaterial.clearcoatMapEnabled != 0) {
+      clearcoatFactor *= textureSample(
+        pbr_clearcoatSampler,
+        pbr_clearcoatSamplerSampler,
+        clearcoatUV
+      ).r;
+    }
+    #endif
+    #ifdef HAS_CLEARCOATROUGHNESSMAP
+    if (pbrMaterial.clearcoatRoughnessMapEnabled != 0) {
+      clearcoatRoughness *= textureSample(
+        pbr_clearcoatRoughnessSampler,
+        pbr_clearcoatRoughnessSamplerSampler,
+        clearcoatRoughnessUV
+      ).g;
+    }
+    #endif
+    clearcoatFactor = clamp(clearcoatFactor, 0.0, 1.0);
+    clearcoatRoughness = clamp(clearcoatRoughness, c_MinRoughness, 1.0);
+    let clearcoatNormal = getClearcoatNormal(getTBN(clearcoatNormalUV), n, clearcoatNormalUV);
+
+    var sheenColor = pbrMaterial.sheenColorFactor;
+    var sheenRoughness = pbrMaterial.sheenRoughnessFactor;
+    #ifdef HAS_SHEENCOLORMAP
+    if (pbrMaterial.sheenColorMapEnabled != 0) {
+      sheenColor *= SRGBtoLINEAR(
+        textureSample(
+          pbr_sheenColorSampler,
+          pbr_sheenColorSamplerSampler,
+          sheenColorUV
+        )
+      ).rgb;
+    }
+    #endif
+    #ifdef HAS_SHEENROUGHNESSMAP
+    if (pbrMaterial.sheenRoughnessMapEnabled != 0) {
+      sheenRoughness *= textureSample(
+        pbr_sheenRoughnessSampler,
+        pbr_sheenRoughnessSamplerSampler,
+        sheenRoughnessUV
+      ).a;
+    }
+    #endif
+    sheenRoughness = clamp(sheenRoughness, c_MinRoughness, 1.0);
+
+    var iridescence = pbrMaterial.iridescenceFactor;
+    #ifdef HAS_IRIDESCENCEMAP
+    if (pbrMaterial.iridescenceMapEnabled != 0) {
+      iridescence *= textureSample(
+        pbr_iridescenceSampler,
+        pbr_iridescenceSamplerSampler,
+        iridescenceUV
+      ).r;
+    }
+    #endif
+    iridescence = clamp(iridescence, 0.0, 1.0);
+    var iridescenceThickness = mix(
+      pbrMaterial.iridescenceThicknessRange.x,
+      pbrMaterial.iridescenceThicknessRange.y,
+      0.5
+    );
+    #ifdef HAS_IRIDESCENCETHICKNESSMAP
+    iridescenceThickness = mix(
+      pbrMaterial.iridescenceThicknessRange.x,
+      pbrMaterial.iridescenceThicknessRange.y,
+      textureSample(
+        pbr_iridescenceThicknessSampler,
+        pbr_iridescenceThicknessSamplerSampler,
+        iridescenceThicknessUV
+      ).g
+    );
+    #endif
+
+    var anisotropyStrength = clamp(pbrMaterial.anisotropyStrength, 0.0, 1.0);
+    var anisotropyDirection = normalizeDirection(pbrMaterial.anisotropyDirection);
+    #ifdef HAS_ANISOTROPYMAP
+    if (pbrMaterial.anisotropyMapEnabled != 0) {
+      let anisotropySample = textureSample(
+        pbr_anisotropySampler,
+        pbr_anisotropySamplerSampler,
+        anisotropyUV
+      ).rgb;
+      anisotropyStrength *= anisotropySample.b;
+      let mappedDirection = anisotropySample.rg * 2.0 - 1.0;
+      if (length(mappedDirection) > 0.0001) {
+        anisotropyDirection = normalize(mappedDirection);
+      }
+    }
+    #endif
+    anisotropyDirection = rotateDirection(anisotropyDirection, pbrMaterial.anisotropyRotation);
+    var anisotropyTangent =
+      normalize(tbn[0] * anisotropyDirection.x + tbn[1] * anisotropyDirection.y);
+    if (length(anisotropyTangent) < 0.0001) {
+      anisotropyTangent = normalize(tbn[0]);
+    }
+    let anisotropyViewAlignment = abs(dot(v, anisotropyTangent));
+    perceptualRoughness = mix(
+      perceptualRoughness,
+      clamp(perceptualRoughness * (1.0 - 0.6 * anisotropyViewAlignment), c_MinRoughness, 1.0),
+      anisotropyStrength
+    );
+
     // Roughness is authored as perceptual roughness; as is convention,
     // convert to material roughness by squaring the perceptual roughness [2].
     let alphaRoughness = perceptualRoughness * perceptualRoughness;
 
-    let f0 = vec3<f32>(0.04);
-    var diffuseColor = baseColor.rgb * (vec3<f32>(1.0) - f0);
-    diffuseColor *= 1.0 - metallic;
-    let specularColor = mix(f0, baseColor.rgb, metallic);
+    let dielectricF0 = getDielectricF0(pbrMaterial.ior);
+    var dielectricSpecularF0 = min(
+      vec3f(dielectricF0) * specularFactor * specularIntensity,
+      vec3f(1.0)
+    );
+    let iridescenceTint = getIridescenceTint(iridescence, iridescenceThickness, NdotV);
+    dielectricSpecularF0 = mix(
+      dielectricSpecularF0,
+      dielectricSpecularF0 * iridescenceTint,
+      iridescence
+    );
+    var diffuseColor = baseColor.rgb * (vec3f(1.0) - dielectricSpecularF0);
+    diffuseColor *= (1.0 - metallic) * (1.0 - transmission);
+    var specularColor = mix(dielectricSpecularF0, baseColor.rgb, metallic);
+
+    let baseLayerEnergy = 1.0 - clearcoatFactor * 0.25;
+    diffuseColor *= baseLayerEnergy;
+    specularColor *= baseLayerEnergy;
 
     // Compute reflectance.
     let reflectance = max(max(specularColor.r, specularColor.g), specularColor.b);
@@ -17586,11 +19469,6 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
     let reflectance90 = clamp(reflectance * 25.0, 0.0, 1.0);
     let specularEnvironmentR0 = specularColor;
     let specularEnvironmentR90 = vec3<f32>(1.0, 1.0, 1.0) * reflectance90;
-
-    let n = getNormal();                          // 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);
     let reflection = -normalize(reflect(v, n));
 
     var pbrInfo = PBRInfo(
@@ -17613,13 +19491,33 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
     #ifdef USE_LIGHTS
     // Apply ambient light
     PBRInfo_setAmbientLight(&pbrInfo);
-    color += calculateFinalColor(pbrInfo, lighting.ambientColor);
+    color += calculateMaterialLightColor(
+      pbrInfo,
+      lighting.ambientColor,
+      clearcoatNormal,
+      clearcoatFactor,
+      clearcoatRoughness,
+      sheenColor,
+      sheenRoughness,
+      anisotropyTangent,
+      anisotropyStrength
+    );
 
     // Apply directional light
     for (var i = 0; i < lighting.directionalLightCount; i++) {
       if (i < lighting.directionalLightCount) {
         PBRInfo_setDirectionalLight(&pbrInfo, lighting_getDirectionalLight(i).direction);
-        color += calculateFinalColor(pbrInfo, lighting_getDirectionalLight(i).color);
+        color += calculateMaterialLightColor(
+          pbrInfo,
+          lighting_getDirectionalLight(i).color,
+          clearcoatNormal,
+          clearcoatFactor,
+          clearcoatRoughness,
+          sheenColor,
+          sheenRoughness,
+          anisotropyTangent,
+          anisotropyStrength
+        );
       }
     }
 
@@ -17631,7 +19529,35 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
           lighting_getPointLight(i),
           distance(lighting_getPointLight(i).position, fragmentInputs.pbr_vPosition)
         );
-        color += calculateFinalColor(pbrInfo, lighting_getPointLight(i).color / attenuation);
+        color += calculateMaterialLightColor(
+          pbrInfo,
+          lighting_getPointLight(i).color / attenuation,
+          clearcoatNormal,
+          clearcoatFactor,
+          clearcoatRoughness,
+          sheenColor,
+          sheenRoughness,
+          anisotropyTangent,
+          anisotropyStrength
+        );
+      }
+    }
+
+    for (var i = 0; i < lighting.spotLightCount; i++) {
+      if (i < lighting.spotLightCount) {
+        PBRInfo_setSpotLight(&pbrInfo, lighting_getSpotLight(i));
+        let attenuation = getSpotLightAttenuation(lighting_getSpotLight(i), fragmentInputs.pbr_vPosition);
+        color += calculateMaterialLightColor(
+          pbrInfo,
+          lighting_getSpotLight(i).color / attenuation,
+          clearcoatNormal,
+          clearcoatFactor,
+          clearcoatRoughness,
+          sheenColor,
+          sheenRoughness,
+          anisotropyTangent,
+          anisotropyStrength
+        );
       }
     }
     #endif
@@ -17639,27 +19565,40 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
     // Calculate lighting contribution from image based lighting source (IBL)
     #ifdef USE_IBL
     if (pbrMaterial.IBLenabled != 0) {
-      color += getIBLContribution(pbrInfo, n, reflection);
+      color += getIBLContribution(pbrInfo, n, reflection) *
+        calculateAnisotropyBoost(pbrInfo, anisotropyTangent, anisotropyStrength);
+      color += calculateClearcoatIBLContribution(
+        pbrInfo,
+        clearcoatNormal,
+        -normalize(reflect(v, clearcoatNormal)),
+        clearcoatFactor,
+        clearcoatRoughness
+      );
+      color += sheenColor * pbrMaterial.scaleIBLAmbient.x * (1.0 - sheenRoughness) * 0.25;
     }
     #endif
 
     // 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
 
+    var emissive = pbrMaterial.emissiveFactor;
     #ifdef HAS_EMISSIVEMAP
     if (pbrMaterial.emissiveMapEnabled != 0u) {
-      let emissive = SRGBtoLINEAR(
-        textureSample(pbr_emissiveSampler, pbr_emissiveSamplerSampler, fragmentInputs.pbr_vUV)
-      ).rgb * pbrMaterial.emissiveFactor;
-      color += emissive;
+      emissive *= SRGBtoLINEAR(
+        textureSample(pbr_emissiveSampler, pbr_emissiveSamplerSampler, emissiveUV)
+      ).rgb;
     }
     #endif
+    color += emissive * pbrMaterial.emissiveStrength;
+
+    if (transmission > 0.0) {
+      color = mix(color, color * getVolumeAttenuation(thickness), transmission);
+    }
 
     // This section uses mix to override final color for reference app visualization
     // of various parameters in the lighting equation.
@@ -17678,7 +19617,8 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
     #endif
   }
 
-  return vec4<f32>(pow(color, vec3<f32>(1.0 / 2.2)), baseColor.a);
+  let alpha = clamp(baseColor.a * (1.0 - transmission), 0.0, 1.0);
+  return vec4<f32>(pow(color, vec3<f32>(1.0 / 2.2)), alpha);
 }
 `
   );
@@ -17686,7 +19626,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
   // ../../node_modules/@luma.gl/shadertools/dist/modules/lighting/pbr-material/pbr-projection.js
   var uniformBlock2 = (
     /* glsl */
-    `uniform pbrProjectionUniforms {
+    `layout(std140) uniform pbrProjectionUniforms {
   mat4 modelViewProjectionMatrix;
   mat4 modelMatrix;
   mat4 normalMatrix;
@@ -17703,11 +19643,12 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
   camera: vec3<f32>
 };
 
-@binding(0) @group(0) var<uniform> pbrProjection: pbrProjectionUniforms;
+@group(0) @binding(auto) var<uniform> pbrProjection: pbrProjectionUniforms;
 `
   );
   var pbrProjection = {
     name: "pbrProjection",
+    bindingLayout: [{ name: "pbrProjection", group: 0 }],
     source: wgslUniformBlock,
     vs: uniformBlock2,
     fs: uniformBlock2,
@@ -17725,8 +19666,109 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
   var pbrMaterial = {
     props: {},
     uniforms: {},
+    defaultUniforms: {
+      unlit: false,
+      baseColorMapEnabled: false,
+      baseColorFactor: [1, 1, 1, 1],
+      normalMapEnabled: false,
+      normalScale: 1,
+      emissiveMapEnabled: false,
+      emissiveFactor: [0, 0, 0],
+      metallicRoughnessValues: [1, 1],
+      metallicRoughnessMapEnabled: false,
+      occlusionMapEnabled: false,
+      occlusionStrength: 1,
+      alphaCutoffEnabled: false,
+      alphaCutoff: 0.5,
+      IBLenabled: false,
+      scaleIBLAmbient: [1, 1],
+      scaleDiffBaseMR: [0, 0, 0, 0],
+      scaleFGDSpec: [0, 0, 0, 0],
+      specularColorFactor: [1, 1, 1],
+      specularIntensityFactor: 1,
+      specularColorMapEnabled: false,
+      specularIntensityMapEnabled: false,
+      ior: 1.5,
+      transmissionFactor: 0,
+      transmissionMapEnabled: false,
+      thicknessFactor: 0,
+      attenuationDistance: 1e9,
+      attenuationColor: [1, 1, 1],
+      clearcoatFactor: 0,
+      clearcoatRoughnessFactor: 0,
+      clearcoatMapEnabled: false,
+      clearcoatRoughnessMapEnabled: false,
+      sheenColorFactor: [0, 0, 0],
+      sheenRoughnessFactor: 0,
+      sheenColorMapEnabled: false,
+      sheenRoughnessMapEnabled: false,
+      iridescenceFactor: 0,
+      iridescenceIor: 1.3,
+      iridescenceThicknessRange: [100, 400],
+      iridescenceMapEnabled: false,
+      anisotropyStrength: 0,
+      anisotropyRotation: 0,
+      anisotropyDirection: [1, 0],
+      anisotropyMapEnabled: false,
+      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",
-    dependencies: [lighting, pbrProjection],
+    firstBindingSlot: 0,
+    bindingLayout: [
+      { name: "pbrMaterial", group: 3 },
+      { name: "pbr_baseColorSampler", group: 3 },
+      { name: "pbr_normalSampler", group: 3 },
+      { name: "pbr_emissiveSampler", group: 3 },
+      { name: "pbr_metallicRoughnessSampler", group: 3 },
+      { name: "pbr_occlusionSampler", group: 3 },
+      { name: "pbr_specularColorSampler", group: 3 },
+      { name: "pbr_specularIntensitySampler", group: 3 },
+      { name: "pbr_transmissionSampler", group: 3 },
+      { name: "pbr_thicknessSampler", group: 3 },
+      { name: "pbr_clearcoatSampler", group: 3 },
+      { name: "pbr_clearcoatRoughnessSampler", group: 3 },
+      { name: "pbr_clearcoatNormalSampler", group: 3 },
+      { name: "pbr_sheenColorSampler", group: 3 },
+      { name: "pbr_sheenRoughnessSampler", group: 3 },
+      { name: "pbr_iridescenceSampler", group: 3 },
+      { name: "pbr_iridescenceThicknessSampler", group: 3 },
+      { name: "pbr_anisotropySampler", group: 3 }
+    ],
+    dependencies: [lighting, ibl, pbrProjection],
     source,
     vs,
     fs,
@@ -17740,10 +19782,16 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
       HAS_SPECULARCOLORMAP: false,
       HAS_SPECULARINTENSITYMAP: false,
       HAS_TRANSMISSIONMAP: false,
+      HAS_THICKNESSMAP: false,
       HAS_CLEARCOATMAP: false,
+      HAS_CLEARCOATROUGHNESSMAP: false,
+      HAS_CLEARCOATNORMALMAP: false,
       HAS_SHEENCOLORMAP: false,
+      HAS_SHEENROUGHNESSMAP: false,
       HAS_IRIDESCENCEMAP: false,
+      HAS_IRIDESCENCETHICKNESSMAP: false,
       HAS_ANISOTROPYMAP: false,
+      USE_MATERIAL_EXTENSIONS: false,
       ALPHA_CUTOFF: false,
       USE_IBL: false,
       PBR_DEBUG: false
@@ -17769,14 +19817,6 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
       alphaCutoffEnabled: "i32",
       alphaCutoff: "f32",
       // #ifdef ALPHA_CUTOFF
-      // IBL
-      IBLenabled: "i32",
-      scaleIBLAmbient: "vec2<f32>",
-      // #ifdef USE_IBL
-      // debugging flags used for shader output of intermediate PBR variables
-      // #ifdef PBR_DEBUG
-      scaleDiffBaseMR: "vec4<f32>",
-      scaleFGDSpec: "vec4<f32>",
       specularColorFactor: "vec3<f32>",
       specularIntensityFactor: "f32",
       specularColorMapEnabled: "i32",
@@ -17790,9 +19830,11 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
       clearcoatFactor: "f32",
       clearcoatRoughnessFactor: "f32",
       clearcoatMapEnabled: "i32",
+      clearcoatRoughnessMapEnabled: "i32",
       sheenColorFactor: "vec3<f32>",
       sheenRoughnessFactor: "f32",
       sheenColorMapEnabled: "i32",
+      sheenRoughnessMapEnabled: "i32",
       iridescenceFactor: "f32",
       iridescenceIor: "f32",
       iridescenceThicknessRange: "vec2<f32>",
@@ -17801,7 +19843,49 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
       anisotropyRotation: "f32",
       anisotropyDirection: "vec2<f32>",
       anisotropyMapEnabled: "i32",
-      emissiveStrength: "f32"
+      emissiveStrength: "f32",
+      // IBL
+      IBLenabled: "i32",
+      scaleIBLAmbient: "vec2<f32>",
+      // #ifdef USE_IBL
+      // debugging flags used for shader output of intermediate PBR variables
+      // #ifdef PBR_DEBUG
+      scaleDiffBaseMR: "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>"
     }
   };
 
@@ -17810,7 +19894,7 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
   var import_mesh_layers = __toESM(require_mesh_layers(), 1);
 
   // src/mesh-layer/mesh-layer-uniforms.ts
-  var uniformBlock3 = `uniform meshUniforms {
+  var uniformBlock3 = `layout(std140) uniform meshUniforms {
   bool pickFeatureIds;
 } mesh;
 `;
@@ -17893,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);
@@ -17925,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
@@ -18092,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;
@@ -18808,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 = {
@@ -19781,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);
         }
@@ -20065,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 {
@@ -20229,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
@@ -20956,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 = {
@@ -21075,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) {
@@ -24511,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;
@@ -24624,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(`'baseUrl' must be provided to resolve relative url ${url}`);
+    }
+    return baseUrl.endsWith("/") ? `${baseUrl}${url}` : `${baseUrl}/${url}`;
+  }
+  function getResolveBaseUrl(baseUrl) {
     if (!baseUrl) {
-      throw new Error(`'baseUri' must be provided to resolve relative url ${url}`);
+      return void 0;
+    }
+    if (baseUrl.endsWith("/")) {
+      return baseUrl;
     }
-    return baseUrl.substr(0, baseUrl.lastIndexOf("/") + 1) + url;
+    const slashIndex = baseUrl.lastIndexOf("/");
+    return slashIndex >= 0 ? baseUrl.slice(0, slashIndex + 1) : "";
   }
 
   // ../../node_modules/@loaders.gl/gltf/dist/lib/extensions/EXT_meshopt_compression.js
@@ -25670,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();
@@ -25708,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] = {
@@ -25748,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();
@@ -26562,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;
@@ -27843,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 };
@@ -28072,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;
@@ -28216,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: {},
@@ -28254,6 +30349,14 @@ void main(void) {
         }
       }
     }
+    finalizeState(context) {
+      this.state.tileset3d?.destroy();
+      this.state.tileset3d = null;
+      this.state.layerMap = {};
+      this.state.activeViewports = {};
+      this.state.lastUpdatedViewports = null;
+      super.finalizeState(context);
+    }
     activateViewport(viewport) {
       const { activeViewports, lastUpdatedViewports } = this.state;
       this.internalState.viewport = viewport;
@@ -28321,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),
@@ -28408,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,
@@ -28431,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,
@@ -28450,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;
@@ -28525,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([
@@ -29488,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 = {
@@ -29595,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) {
@@ -29609,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({
@@ -29680,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,
@@ -29785,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);
 
@@ -31360,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,
@@ -31612,17 +33715,20 @@ void main(void) {
       const { fetch: fetch2 } = this.props;
       loadOptions = {
         ...loadOptions,
-        mimeType: "application/x-protobuf",
+        core: {
+          ...loadOptions?.core,
+          mimeType: "application/x-protobuf"
+        },
         mvt: {
           ...loadOptions?.mvt,
+          shape: binary ? "binary" : "geojson",
           coordinates: this.context.viewport.resolution ? "wgs84" : "local",
           tileIndex: index
           // Local worker debug
           // workerUrl: `modules/mvt/dist/mvt-loader.worker.js`
           // Set worker to null to skip web workers
           // workerUrl: null
-        },
-        gis: binary ? { format: "binary" } : {}
+        }
       };
       return fetch2(url, { propName: "data", layer: this, loadOptions, signal });
     }
@@ -31638,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;
     }