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

package/dist/dist.dev.js

@@ -14996,7 +14996,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))
+          )
         )
       );
     }
@@ -15166,7 +15171,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;
@@ -16084,6 +16089,35 @@ out float vTime;
   // ../../node_modules/@luma.gl/gltf/dist/parsers/parse-pbr-material.js
   var import_core20 = __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) {
     return {
@@ -16095,11 +16129,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 +16141,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,17 +16151,17 @@ 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 {};
@@ -16159,7 +16193,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) {
@@ -16182,68 +16217,415 @@ 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, options.gltf);
     }
     return parsedMaterial;
   }
-  function parseMaterial(device, material, parsedMaterial) {
-    parsedMaterial.uniforms.unlit = Boolean(material.unlit);
+  function warnOnMissingExpectedAttributes(material, attributes) {
+    const uvDependentTextureSlots = getUvDependentTextureSlots(material);
+    if (uvDependentTextureSlots.length > 0 && !attributes["TEXCOORD_0"]) {
+      import_core20.log.warn(`glTF material uses ${uvDependentTextureSlots.join(", ")} but primitive is missing TEXCOORD_0; textured shading will sample the default UV coordinates`)();
+    }
+    const isUnlitMaterial = Boolean(material.unlit || material.extensions?.KHR_materials_unlit);
+    if (isUnlitMaterial || attributes["NORMAL"]) {
+      return;
+    }
+    const missingNormalReason = material.normalTexture ? "lit PBR shading with normalTexture" : "lit PBR shading";
+    import_core20.log.warn(`glTF primitive is missing NORMAL while using ${missingNormalReason}; shading will fall back to geometric normals`)();
+  }
+  function getUvDependentTextureSlots(material) {
+    const uvDependentTextureSlots = [];
+    if (material.pbrMetallicRoughness?.baseColorTexture) {
+      uvDependentTextureSlots.push("baseColorTexture");
+    }
+    if (material.pbrMetallicRoughness?.metallicRoughnessTexture) {
+      uvDependentTextureSlots.push("metallicRoughnessTexture");
+    }
+    if (material.normalTexture) {
+      uvDependentTextureSlots.push("normalTexture");
+    }
+    if (material.occlusionTexture) {
+      uvDependentTextureSlots.push("occlusionTexture");
+    }
+    if (material.emissiveTexture) {
+      uvDependentTextureSlots.push("emissiveTexture");
+    }
+    if (material.extensions?.KHR_materials_specular?.specularTexture) {
+      uvDependentTextureSlots.push("KHR_materials_specular.specularTexture");
+    }
+    if (material.extensions?.KHR_materials_specular?.specularColorTexture) {
+      uvDependentTextureSlots.push("KHR_materials_specular.specularColorTexture");
+    }
+    if (material.extensions?.KHR_materials_transmission?.transmissionTexture) {
+      uvDependentTextureSlots.push("KHR_materials_transmission.transmissionTexture");
+    }
+    if (material.extensions?.KHR_materials_clearcoat?.clearcoatTexture) {
+      uvDependentTextureSlots.push("KHR_materials_clearcoat.clearcoatTexture");
+    }
+    if (material.extensions?.KHR_materials_clearcoat?.clearcoatRoughnessTexture) {
+      uvDependentTextureSlots.push("KHR_materials_clearcoat.clearcoatRoughnessTexture");
+    }
+    if (material.extensions?.KHR_materials_sheen?.sheenColorTexture) {
+      uvDependentTextureSlots.push("KHR_materials_sheen.sheenColorTexture");
+    }
+    if (material.extensions?.KHR_materials_sheen?.sheenRoughnessTexture) {
+      uvDependentTextureSlots.push("KHR_materials_sheen.sheenRoughnessTexture");
+    }
+    if (material.extensions?.KHR_materials_iridescence?.iridescenceTexture) {
+      uvDependentTextureSlots.push("KHR_materials_iridescence.iridescenceTexture");
+    }
+    if (material.extensions?.KHR_materials_anisotropy?.anisotropyTexture) {
+      uvDependentTextureSlots.push("KHR_materials_anisotropy.anisotropyTexture");
+    }
+    return uvDependentTextureSlots;
+  }
+  function parseMaterial(device, material, parsedMaterial, gltf) {
+    parsedMaterial.uniforms.unlit = Boolean(material.unlit || material.extensions?.KHR_materials_unlit);
     if (material.pbrMetallicRoughness) {
-      parsePbrMetallicRoughness(device, material.pbrMetallicRoughness, parsedMaterial);
+      parsePbrMetallicRoughness(device, material.pbrMetallicRoughness, parsedMaterial, gltf);
     }
     if (material.normalTexture) {
-      addTexture(device, material.normalTexture, "pbr_normalSampler", "HAS_NORMALMAP", parsedMaterial);
+      addTexture(device, material.normalTexture, "pbr_normalSampler", parsedMaterial, {
+        featureOptions: {
+          define: "HAS_NORMALMAP",
+          enabledUniformName: "normalMapEnabled"
+        },
+        gltf
+      });
       const { scale: 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
+      });
       const { strength = 1 } = material.occlusionTexture;
       parsedMaterial.uniforms.occlusionStrength = strength;
     }
+    parsedMaterial.uniforms.emissiveFactor = material.emissiveFactor || [0, 0, 0];
     if (material.emissiveTexture) {
-      addTexture(device, material.emissiveTexture, "pbr_emissiveSampler", "HAS_EMISSIVEMAP", parsedMaterial);
-      parsedMaterial.uniforms.emissiveFactor = material.emissiveFactor || [0, 0, 0];
+      addTexture(device, material.emissiveTexture, "pbr_emissiveSampler", parsedMaterial, {
+        featureOptions: {
+          define: "HAS_EMISSIVEMAP",
+          enabledUniformName: "emissiveMapEnabled"
+        },
+        gltf
+      });
     }
-    switch (material.alphaMode || "MASK") {
-      case "MASK":
+    parseMaterialExtensions(device, material.extensions, parsedMaterial, gltf);
+    switch (material.alphaMode || "OPAQUE") {
+      case "OPAQUE":
+        break;
+      case "MASK": {
         const { alphaCutoff = 0.5 } = material;
         parsedMaterial.defines["ALPHA_CUTOFF"] = true;
+        parsedMaterial.uniforms.alphaCutoffEnabled = true;
         parsedMaterial.uniforms.alphaCutoff = alphaCutoff;
         break;
+      }
       case "BLEND":
         import_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
-        ];
+        applyAlphaBlendParameters(parsedMaterial);
         break;
     }
   }
-  function parsePbrMetallicRoughness(device, pbrMetallicRoughness, parsedMaterial) {
+  function applyAlphaBlendParameters(parsedMaterial) {
+    parsedMaterial.parameters.blend = true;
+    parsedMaterial.parameters.blendColorOperation = "add";
+    parsedMaterial.parameters.blendColorSrcFactor = "src-alpha";
+    parsedMaterial.parameters.blendColorDstFactor = "one-minus-src-alpha";
+    parsedMaterial.parameters.blendAlphaOperation = "add";
+    parsedMaterial.parameters.blendAlphaSrcFactor = "one";
+    parsedMaterial.parameters.blendAlphaDstFactor = "one-minus-src-alpha";
+    parsedMaterial.glParameters["blend"] = true;
+    parsedMaterial.glParameters["blendEquation"] = GLEnum.FUNC_ADD;
+    parsedMaterial.glParameters["blendFunc"] = [
+      GLEnum.SRC_ALPHA,
+      GLEnum.ONE_MINUS_SRC_ALPHA,
+      GLEnum.ONE,
+      GLEnum.ONE_MINUS_SRC_ALPHA
+    ];
+  }
+  function applyTransmissionBlendApproximation(parsedMaterial) {
+    parsedMaterial.parameters.blend = true;
+    parsedMaterial.parameters.depthWriteEnabled = false;
+    parsedMaterial.parameters.blendColorOperation = "add";
+    parsedMaterial.parameters.blendColorSrcFactor = "one";
+    parsedMaterial.parameters.blendColorDstFactor = "one-minus-src-alpha";
+    parsedMaterial.parameters.blendAlphaOperation = "add";
+    parsedMaterial.parameters.blendAlphaSrcFactor = "one";
+    parsedMaterial.parameters.blendAlphaDstFactor = "one-minus-src-alpha";
+    parsedMaterial.glParameters["blend"] = true;
+    parsedMaterial.glParameters["depthMask"] = false;
+    parsedMaterial.glParameters["blendEquation"] = GLEnum.FUNC_ADD;
+    parsedMaterial.glParameters["blendFunc"] = [
+      GLEnum.ONE,
+      GLEnum.ONE_MINUS_SRC_ALPHA,
+      GLEnum.ONE,
+      GLEnum.ONE_MINUS_SRC_ALPHA
+    ];
+  }
+  function parsePbrMetallicRoughness(device, pbrMetallicRoughness, parsedMaterial, gltf) {
     if (pbrMetallicRoughness.baseColorTexture) {
-      addTexture(device, pbrMetallicRoughness.baseColorTexture, "pbr_baseColorSampler", "HAS_BASECOLORMAP", parsedMaterial);
+      addTexture(device, pbrMetallicRoughness.baseColorTexture, "pbr_baseColorSampler", parsedMaterial, {
+        featureOptions: {
+          define: "HAS_BASECOLORMAP",
+          enabledUniformName: "baseColorMapEnabled"
+        },
+        gltf
+      });
     }
     parsedMaterial.uniforms.baseColorFactor = pbrMetallicRoughness.baseColorFactor || [1, 1, 1, 1];
     if (pbrMetallicRoughness.metallicRoughnessTexture) {
-      addTexture(device, pbrMetallicRoughness.metallicRoughnessTexture, "pbr_metallicRoughnessSampler", "HAS_METALROUGHNESSMAP", parsedMaterial);
+      addTexture(device, pbrMetallicRoughness.metallicRoughnessTexture, "pbr_metallicRoughnessSampler", parsedMaterial, {
+        featureOptions: {
+          define: "HAS_METALROUGHNESSMAP",
+          enabledUniformName: "metallicRoughnessMapEnabled"
+        },
+        gltf
+      });
     }
     const { metallicFactor = 1, roughnessFactor = 1 } = pbrMetallicRoughness;
     parsedMaterial.uniforms.metallicRoughnessValues = [metallicFactor, roughnessFactor];
   }
-  function addTexture(device, gltfTexture, uniformName, define2, parsedMaterial) {
-    const image = gltfTexture.texture.source.image;
+  function parseMaterialExtensions(device, extensions, parsedMaterial, gltf) {
+    if (!extensions) {
+      return;
+    }
+    if (hasMaterialExtensionShading(extensions)) {
+      parsedMaterial.defines["USE_MATERIAL_EXTENSIONS"] = true;
+    }
+    parseSpecularExtension(device, extensions.KHR_materials_specular, parsedMaterial, gltf);
+    parseIorExtension(extensions.KHR_materials_ior, parsedMaterial);
+    parseTransmissionExtension(device, extensions.KHR_materials_transmission, parsedMaterial, gltf);
+    parseVolumeExtension(device, extensions.KHR_materials_volume, parsedMaterial, gltf);
+    parseClearcoatExtension(device, extensions.KHR_materials_clearcoat, parsedMaterial, gltf);
+    parseSheenExtension(device, extensions.KHR_materials_sheen, parsedMaterial, gltf);
+    parseIridescenceExtension(device, extensions.KHR_materials_iridescence, parsedMaterial, gltf);
+    parseAnisotropyExtension(device, extensions.KHR_materials_anisotropy, parsedMaterial, gltf);
+    parseEmissiveStrengthExtension(extensions.KHR_materials_emissive_strength, parsedMaterial);
+  }
+  function hasMaterialExtensionShading(extensions) {
+    return Boolean(extensions.KHR_materials_specular || extensions.KHR_materials_ior || extensions.KHR_materials_transmission || extensions.KHR_materials_volume || extensions.KHR_materials_clearcoat || extensions.KHR_materials_sheen || extensions.KHR_materials_iridescence || extensions.KHR_materials_anisotropy);
+  }
+  function parseSpecularExtension(device, extension, parsedMaterial, gltf) {
+    if (!extension) {
+      return;
+    }
+    if (extension.specularColorFactor) {
+      parsedMaterial.uniforms.specularColorFactor = extension.specularColorFactor;
+    }
+    if (extension.specularFactor !== void 0) {
+      parsedMaterial.uniforms.specularIntensityFactor = extension.specularFactor;
+    }
+    if (extension.specularColorTexture) {
+      addTexture(device, extension.specularColorTexture, "pbr_specularColorSampler", parsedMaterial, {
+        featureOptions: {
+          define: "HAS_SPECULARCOLORMAP",
+          enabledUniformName: "specularColorMapEnabled"
+        },
+        gltf
+      });
+    }
+    if (extension.specularTexture) {
+      addTexture(device, extension.specularTexture, "pbr_specularIntensitySampler", parsedMaterial, {
+        featureOptions: {
+          define: "HAS_SPECULARINTENSITYMAP",
+          enabledUniformName: "specularIntensityMapEnabled"
+        },
+        gltf
+      });
+    }
+  }
+  function parseIorExtension(extension, parsedMaterial) {
+    if (extension?.ior !== void 0) {
+      parsedMaterial.uniforms.ior = extension.ior;
+    }
+  }
+  function parseTransmissionExtension(device, extension, parsedMaterial, gltf) {
+    if (!extension) {
+      return;
+    }
+    if (extension.transmissionFactor !== void 0) {
+      parsedMaterial.uniforms.transmissionFactor = extension.transmissionFactor;
+    }
+    if (extension.transmissionTexture) {
+      addTexture(device, extension.transmissionTexture, "pbr_transmissionSampler", parsedMaterial, {
+        featureOptions: {
+          define: "HAS_TRANSMISSIONMAP",
+          enabledUniformName: "transmissionMapEnabled"
+        },
+        gltf
+      });
+    }
+    if ((extension.transmissionFactor ?? 0) > 0 || extension.transmissionTexture) {
+      import_core20.log.warn("KHR_materials_transmission uses a premultiplied-alpha blending approximation and may require mesh sorting")();
+      applyTransmissionBlendApproximation(parsedMaterial);
+    }
+  }
+  function parseVolumeExtension(device, extension, parsedMaterial, gltf) {
+    if (!extension) {
+      return;
+    }
+    if (extension.thicknessFactor !== void 0) {
+      parsedMaterial.uniforms.thicknessFactor = extension.thicknessFactor;
+    }
+    if (extension.thicknessTexture) {
+      addTexture(device, extension.thicknessTexture, "pbr_thicknessSampler", parsedMaterial, {
+        featureOptions: {
+          define: "HAS_THICKNESSMAP"
+        },
+        gltf
+      });
+    }
+    if (extension.attenuationDistance !== void 0) {
+      parsedMaterial.uniforms.attenuationDistance = extension.attenuationDistance;
+    }
+    if (extension.attenuationColor) {
+      parsedMaterial.uniforms.attenuationColor = extension.attenuationColor;
+    }
+  }
+  function parseClearcoatExtension(device, extension, parsedMaterial, gltf) {
+    if (!extension) {
+      return;
+    }
+    if (extension.clearcoatFactor !== void 0) {
+      parsedMaterial.uniforms.clearcoatFactor = extension.clearcoatFactor;
+    }
+    if (extension.clearcoatRoughnessFactor !== void 0) {
+      parsedMaterial.uniforms.clearcoatRoughnessFactor = extension.clearcoatRoughnessFactor;
+    }
+    if (extension.clearcoatTexture) {
+      addTexture(device, extension.clearcoatTexture, "pbr_clearcoatSampler", parsedMaterial, {
+        featureOptions: {
+          define: "HAS_CLEARCOATMAP",
+          enabledUniformName: "clearcoatMapEnabled"
+        },
+        gltf
+      });
+    }
+    if (extension.clearcoatRoughnessTexture) {
+      addTexture(device, extension.clearcoatRoughnessTexture, "pbr_clearcoatRoughnessSampler", parsedMaterial, {
+        featureOptions: {
+          define: "HAS_CLEARCOATROUGHNESSMAP",
+          enabledUniformName: "clearcoatRoughnessMapEnabled"
+        },
+        gltf
+      });
+    }
+    if (extension.clearcoatNormalTexture) {
+      addTexture(device, extension.clearcoatNormalTexture, "pbr_clearcoatNormalSampler", parsedMaterial, {
+        featureOptions: {
+          define: "HAS_CLEARCOATNORMALMAP"
+        },
+        gltf
+      });
+    }
+  }
+  function parseSheenExtension(device, extension, parsedMaterial, gltf) {
+    if (!extension) {
+      return;
+    }
+    if (extension.sheenColorFactor) {
+      parsedMaterial.uniforms.sheenColorFactor = extension.sheenColorFactor;
+    }
+    if (extension.sheenRoughnessFactor !== void 0) {
+      parsedMaterial.uniforms.sheenRoughnessFactor = extension.sheenRoughnessFactor;
+    }
+    if (extension.sheenColorTexture) {
+      addTexture(device, extension.sheenColorTexture, "pbr_sheenColorSampler", parsedMaterial, {
+        featureOptions: {
+          define: "HAS_SHEENCOLORMAP",
+          enabledUniformName: "sheenColorMapEnabled"
+        },
+        gltf
+      });
+    }
+    if (extension.sheenRoughnessTexture) {
+      addTexture(device, extension.sheenRoughnessTexture, "pbr_sheenRoughnessSampler", parsedMaterial, {
+        featureOptions: {
+          define: "HAS_SHEENROUGHNESSMAP",
+          enabledUniformName: "sheenRoughnessMapEnabled"
+        },
+        gltf
+      });
+    }
+  }
+  function parseIridescenceExtension(device, extension, parsedMaterial, gltf) {
+    if (!extension) {
+      return;
+    }
+    if (extension.iridescenceFactor !== void 0) {
+      parsedMaterial.uniforms.iridescenceFactor = extension.iridescenceFactor;
+    }
+    if (extension.iridescenceIor !== void 0) {
+      parsedMaterial.uniforms.iridescenceIor = extension.iridescenceIor;
+    }
+    if (extension.iridescenceThicknessMinimum !== void 0 || extension.iridescenceThicknessMaximum !== void 0) {
+      parsedMaterial.uniforms.iridescenceThicknessRange = [
+        extension.iridescenceThicknessMinimum ?? 100,
+        extension.iridescenceThicknessMaximum ?? 400
+      ];
+    }
+    if (extension.iridescenceTexture) {
+      addTexture(device, extension.iridescenceTexture, "pbr_iridescenceSampler", parsedMaterial, {
+        featureOptions: {
+          define: "HAS_IRIDESCENCEMAP",
+          enabledUniformName: "iridescenceMapEnabled"
+        },
+        gltf
+      });
+    }
+    if (extension.iridescenceThicknessTexture) {
+      addTexture(device, extension.iridescenceThicknessTexture, "pbr_iridescenceThicknessSampler", parsedMaterial, {
+        featureOptions: {
+          define: "HAS_IRIDESCENCETHICKNESSMAP"
+        },
+        gltf
+      });
+    }
+  }
+  function parseAnisotropyExtension(device, extension, parsedMaterial, gltf) {
+    if (!extension) {
+      return;
+    }
+    if (extension.anisotropyStrength !== void 0) {
+      parsedMaterial.uniforms.anisotropyStrength = extension.anisotropyStrength;
+    }
+    if (extension.anisotropyRotation !== void 0) {
+      parsedMaterial.uniforms.anisotropyRotation = extension.anisotropyRotation;
+    }
+    if (extension.anisotropyTexture) {
+      addTexture(device, extension.anisotropyTexture, "pbr_anisotropySampler", parsedMaterial, {
+        featureOptions: {
+          define: "HAS_ANISOTROPYMAP",
+          enabledUniformName: "anisotropyMapEnabled"
+        },
+        gltf
+      });
+    }
+  }
+  function parseEmissiveStrengthExtension(extension, parsedMaterial) {
+    if (extension?.emissiveStrength !== void 0) {
+      parsedMaterial.uniforms.emissiveStrength = extension.emissiveStrength;
+    }
+  }
+  function addTexture(device, gltfTexture, uniformName, parsedMaterial, textureParseOptions = {}) {
+    const { featureOptions = {}, gltf } = textureParseOptions;
+    const { define: define2, enabledUniformName } = featureOptions;
+    const resolvedTextureInfo = resolveTextureInfo(gltfTexture, gltf);
+    const image = resolvedTextureInfo.texture?.source?.image;
+    if (!image) {
+      import_core20.log.warn(`Skipping unresolved glTF texture for ${String(uniformName)}`)();
+      return;
+    }
     const gltfSampler = {
       wrapS: 10497,
       // default REPEAT S (U) wrapping mode.
@@ -16253,10 +16635,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 +16656,34 @@ out float vTime;
     parsedMaterial.bindings[uniformName] = texture;
     if (define2)
       parsedMaterial.defines[define2] = true;
+    if (enabledUniformName) {
+      parsedMaterial.uniforms[enabledUniformName] = true;
+    }
     parsedMaterial.generatedTextures.push(texture);
   }
+  function resolveTextureInfo(gltfTexture, gltf) {
+    if (gltfTexture.texture || gltfTexture.index === void 0 || !gltf?.textures) {
+      return gltfTexture;
+    }
+    const resolvedTextureEntry = gltf.textures[gltfTexture.index];
+    if (!resolvedTextureEntry) {
+      return gltfTexture;
+    }
+    if ("texture" in resolvedTextureEntry && resolvedTextureEntry.texture) {
+      return {
+        ...resolvedTextureEntry,
+        ...gltfTexture,
+        texture: resolvedTextureEntry.texture
+      };
+    }
+    if (!("source" in resolvedTextureEntry)) {
+      return gltfTexture;
+    }
+    return {
+      ...gltfTexture,
+      texture: resolvedTextureEntry
+    };
+  }
   function createCompressedTextureFallback(device, baseOptions) {
     return device.createTexture({
       ...baseOptions,
@@ -16385,77 +16793,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 +16845,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 +16879,85 @@ 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 +16967,104 @@ 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 { 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({ 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({ 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),
+        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),
+        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),
+        direction: directionalLight.direction
+      };
       currentLight++;
       directionalLightCount++;
     }
-    if (pointLights.length + directionalLights.length > MAX_LIGHTS) {
+    if (pointLights.length + spotLights.length + directionalLights.length > MAX_LIGHTS) {
       import_core21.log.warn(`MAX_LIGHTS exceeded, truncating to ${MAX_LIGHTS}`)();
     }
-    lightSourceUniforms.directionalLightCount = directionalLightCount;
-    lightSourceUniforms.pointLightCount = pointLightCount;
-    return lightSourceUniforms;
+    return {
+      ambientColor: convertColor(ambientLight),
+      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,6 +17076,9 @@ fn getPointLightAttenuation(pointLight: PointLight, distance: f32) -> f32 {
         case "point":
           lightSources.pointLights?.push(light);
           break;
+        case "spot":
+          lightSources.spotLights?.push(light);
+          break;
         default:
       }
     }
@@ -16732,6 +17088,68 @@ fn getPointLightAttenuation(pointLight: PointLight, distance: f32) -> f32 {
     const { color = [0, 0, 0], intensity = 1 } = colorDef;
     return color.map((component) => component * intensity / COLOR_FACTOR);
   }
+  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 = (
@@ -16775,7 +17193,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 +17233,12 @@ uniform pbrMaterialUniforms {
   float clearcoatFactor;
   float clearcoatRoughnessFactor;
   bool clearcoatMapEnabled;
+  bool clearcoatRoughnessMapEnabled;
 
   vec3 sheenColorFactor;
   float sheenRoughnessFactor;
   bool sheenColorMapEnabled;
+  bool sheenRoughnessMapEnabled;
 
   float iridescenceFactor;
   float iridescenceIor;
@@ -16868,26 +17288,33 @@ 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;
@@ -16924,6 +17351,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,11 +17368,9 @@ 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()
+// Build the tangent basis from interpolated attributes or screen-space derivatives.
+mat3 getTBN()
 {
-  // Retrieve the tangent space matrix
 #ifndef HAS_TANGENTS
   vec3 pos_dx = dFdx(pbr_vPosition);
   vec3 pos_dy = dFdy(pbr_vPosition);
@@ -16964,9 +17391,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)
+{
+  vec3 n = texture(normalSampler, pbr_vUV).rgb;
+  return normalize(tbn * ((2.0 * n - 1.0) * vec3(normalScale, normalScale, 1.0)));
+}
+
+vec3 getNormal(mat3 tbn)
+{
 #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);
 #else
   // The tbn matrix is linearly interpolated, so we need to re-normalize
   vec3 n = normalize(tbn[2].xyz);
@@ -16975,6 +17414,15 @@ vec3 getNormal()
   return n;
 }
 
+vec3 getClearcoatNormal(mat3 tbn, vec3 baseNormal)
+{
+#ifdef HAS_CLEARCOATNORMALMAP
+  return getMappedNormal(pbr_clearcoatNormalSampler, tbn, 1.0);
+#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 +17498,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 +17685,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);
@@ -17096,40 +17712,280 @@ vec4 pbr_filterColor(vec4 colorUnused)
   vec4 baseColor = pbrMaterial.baseColorFactor;
 #endif
 
-#ifdef ALPHA_CUTOFF
-  if (baseColor.a < pbrMaterial.alphaCutoff) {
-    discard;
-  }
+#ifdef ALPHA_CUTOFF
+  if (baseColor.a < pbrMaterial.alphaCutoff) {
+    discard;
+  }
+#endif
+
+  vec3 color = vec3(0, 0, 0);
+
+  float transmission = 0.0;
+
+  if(pbrMaterial.unlit){
+    color.rgb = baseColor.rgb;
+  }
+  else{
+    // Metallic and Roughness material properties are packed together
+    // In glTF, these factors can be specified by fixed scalar values
+    // or from a metallic-roughness map
+    float perceptualRoughness = pbrMaterial.metallicRoughnessValues.y;
+    float metallic = pbrMaterial.metallicRoughnessValues.x;
+#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);
+    perceptualRoughness = mrSample.g * perceptualRoughness;
+    metallic = mrSample.b * metallic;
+#endif
+    perceptualRoughness = clamp(perceptualRoughness, c_MinRoughness, 1.0);
+    metallic = clamp(metallic, 0.0, 1.0);
+    mat3 tbn = getTBN();
+    vec3 n = getNormal(tbn);                          // normal at surface point
+    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, pbr_vUV).r;
+        color = mix(color, color * ao, pbrMaterial.occlusionStrength);
+      }
+#endif
+
+      vec3 emissive = pbrMaterial.emissiveFactor;
+#ifdef HAS_EMISSIVEMAP
+      if (pbrMaterial.emissiveMapEnabled) {
+        emissive *= SRGBtoLINEAR(texture(pbr_emissiveSampler, pbr_vUV)).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, pbr_vUV).a;
+    }
+#endif
+
+    vec3 specularFactor = pbrMaterial.specularColorFactor;
+#ifdef HAS_SPECULARCOLORMAP
+    if (pbrMaterial.specularColorMapEnabled) {
+      specularFactor *= SRGBtoLINEAR(texture(pbr_specularColorSampler, pbr_vUV)).rgb;
+    }
+#endif
+
+    transmission = pbrMaterial.transmissionFactor;
+#ifdef HAS_TRANSMISSIONMAP
+    if (pbrMaterial.transmissionMapEnabled) {
+      transmission *= texture(pbr_transmissionSampler, pbr_vUV).r;
+    }
+#endif
+    transmission = clamp(transmission * (1.0 - metallic), 0.0, 1.0);
+    float thickness = max(pbrMaterial.thicknessFactor, 0.0);
+#ifdef HAS_THICKNESSMAP
+    thickness *= texture(pbr_thicknessSampler, pbr_vUV).g;
+#endif
+
+    float clearcoatFactor = pbrMaterial.clearcoatFactor;
+    float clearcoatRoughness = pbrMaterial.clearcoatRoughnessFactor;
+#ifdef HAS_CLEARCOATMAP
+    if (pbrMaterial.clearcoatMapEnabled) {
+      clearcoatFactor *= texture(pbr_clearcoatSampler, pbr_vUV).r;
+    }
+#endif
+#ifdef HAS_CLEARCOATROUGHNESSMAP
+    if (pbrMaterial.clearcoatRoughnessMapEnabled) {
+      clearcoatRoughness *= texture(pbr_clearcoatRoughnessSampler, pbr_vUV).g;
+    }
+#endif
+    clearcoatFactor = clamp(clearcoatFactor, 0.0, 1.0);
+    clearcoatRoughness = clamp(clearcoatRoughness, c_MinRoughness, 1.0);
+    vec3 clearcoatNormal = getClearcoatNormal(tbn, n);
+
+    vec3 sheenColor = pbrMaterial.sheenColorFactor;
+    float sheenRoughness = pbrMaterial.sheenRoughnessFactor;
+#ifdef HAS_SHEENCOLORMAP
+    if (pbrMaterial.sheenColorMapEnabled) {
+      sheenColor *= SRGBtoLINEAR(texture(pbr_sheenColorSampler, pbr_vUV)).rgb;
+    }
+#endif
+#ifdef HAS_SHEENROUGHNESSMAP
+    if (pbrMaterial.sheenRoughnessMapEnabled) {
+      sheenRoughness *= texture(pbr_sheenRoughnessSampler, pbr_vUV).a;
+    }
 #endif
+    sheenRoughness = clamp(sheenRoughness, c_MinRoughness, 1.0);
 
-  vec3 color = vec3(0, 0, 0);
+    float iridescence = pbrMaterial.iridescenceFactor;
+#ifdef HAS_IRIDESCENCEMAP
+    if (pbrMaterial.iridescenceMapEnabled) {
+      iridescence *= texture(pbr_iridescenceSampler, pbr_vUV).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, pbr_vUV).g
+    );
+#endif
 
-  if(pbrMaterial.unlit){
-    color.rgb = baseColor.rgb;
-  }
-  else{
-    // Metallic and Roughness material properties are packed together
-    // In glTF, these factors can be specified by fixed scalar values
-    // or from a metallic-roughness map
-    float perceptualRoughness = pbrMaterial.metallicRoughnessValues.y;
-    float metallic = pbrMaterial.metallicRoughnessValues.x;
-#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);
-    perceptualRoughness = mrSample.g * perceptualRoughness;
-    metallic = mrSample.b * metallic;
+    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, pbr_vUV).rgb;
+      anisotropyStrength *= anisotropySample.b;
+      vec2 mappedDirection = anisotropySample.rg * 2.0 - 1.0;
+      if (length(mappedDirection) > 0.0001) {
+        anisotropyDirection = normalize(mappedDirection);
+      }
+    }
 #endif
-    perceptualRoughness = clamp(perceptualRoughness, c_MinRoughness, 1.0);
-    metallic = clamp(metallic, 0.0, 1.0);
+    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 +17997,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 +18020,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 +18055,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,7 +18091,16 @@ 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
 
@@ -17204,12 +18112,17 @@ vec4 pbr_filterColor(vec4 colorUnused)
     }
 #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, pbr_vUV)).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 +18142,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);
 }
 `
   );
@@ -17295,6 +18209,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,
@@ -17307,38 +18257,77 @@ struct pbrMaterialUniforms {
   // #endif
 }
 
-@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,11 +18368,9 @@ 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
+// Build the tangent basis from interpolated attributes or screen-space derivatives.
+fn getTBN() -> 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));
@@ -17401,16 +18388,52 @@ 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
+) -> vec3f
+{
+  let n = textureSample(normalSampler, normalSamplerBinding, fragmentInputs.pbr_vUV).rgb;
+  return normalize(tbn * ((2.0 * n - 1.0) * vec3f(normalScale, normalScale, 1.0)));
+}
+
+fn getNormal(tbn: mat3x3f) -> 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
+  );
 #endif
 
   return n;
 }
 
+fn getClearcoatNormal(tbn: mat3x3f, baseNormal: vec3f) -> vec3f
+{
+#ifdef HAS_CLEARCOATNORMALMAP
+  return getMappedNormal(
+    pbr_clearcoatNormalSampler,
+    pbr_clearcoatNormalSamplerSampler,
+    tbn,
+    1.0
+  );
+#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 +18444,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 +18523,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 +18713,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);
@@ -17545,6 +18747,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;
@@ -17567,14 +18770,308 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
     #endif
     perceptualRoughness = clamp(perceptualRoughness, c_MinRoughness, 1.0);
     metallic = clamp(metallic, 0.0, 1.0);
+    let tbn = getTBN();
+    let n = getNormal(tbn);                          // normal at surface point
+    let 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, fragmentInputs.pbr_vUV).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, fragmentInputs.pbr_vUV)
+        ).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,
+        fragmentInputs.pbr_vUV
+      ).a;
+    }
+    #endif
+
+    var specularFactor = pbrMaterial.specularColorFactor;
+    #ifdef HAS_SPECULARCOLORMAP
+    if (pbrMaterial.specularColorMapEnabled != 0) {
+      specularFactor *= SRGBtoLINEAR(
+        textureSample(
+          pbr_specularColorSampler,
+          pbr_specularColorSamplerSampler,
+          fragmentInputs.pbr_vUV
+        )
+      ).rgb;
+    }
+    #endif
+
+    transmission = pbrMaterial.transmissionFactor;
+    #ifdef HAS_TRANSMISSIONMAP
+    if (pbrMaterial.transmissionMapEnabled != 0) {
+      transmission *= textureSample(
+        pbr_transmissionSampler,
+        pbr_transmissionSamplerSampler,
+        fragmentInputs.pbr_vUV
+      ).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,
+      fragmentInputs.pbr_vUV
+    ).g;
+    #endif
+
+    var clearcoatFactor = pbrMaterial.clearcoatFactor;
+    var clearcoatRoughness = pbrMaterial.clearcoatRoughnessFactor;
+    #ifdef HAS_CLEARCOATMAP
+    if (pbrMaterial.clearcoatMapEnabled != 0) {
+      clearcoatFactor *= textureSample(
+        pbr_clearcoatSampler,
+        pbr_clearcoatSamplerSampler,
+        fragmentInputs.pbr_vUV
+      ).r;
+    }
+    #endif
+    #ifdef HAS_CLEARCOATROUGHNESSMAP
+    if (pbrMaterial.clearcoatRoughnessMapEnabled != 0) {
+      clearcoatRoughness *= textureSample(
+        pbr_clearcoatRoughnessSampler,
+        pbr_clearcoatRoughnessSamplerSampler,
+        fragmentInputs.pbr_vUV
+      ).g;
+    }
+    #endif
+    clearcoatFactor = clamp(clearcoatFactor, 0.0, 1.0);
+    clearcoatRoughness = clamp(clearcoatRoughness, c_MinRoughness, 1.0);
+    let clearcoatNormal = getClearcoatNormal(tbn, n);
+
+    var sheenColor = pbrMaterial.sheenColorFactor;
+    var sheenRoughness = pbrMaterial.sheenRoughnessFactor;
+    #ifdef HAS_SHEENCOLORMAP
+    if (pbrMaterial.sheenColorMapEnabled != 0) {
+      sheenColor *= SRGBtoLINEAR(
+        textureSample(
+          pbr_sheenColorSampler,
+          pbr_sheenColorSamplerSampler,
+          fragmentInputs.pbr_vUV
+        )
+      ).rgb;
+    }
+    #endif
+    #ifdef HAS_SHEENROUGHNESSMAP
+    if (pbrMaterial.sheenRoughnessMapEnabled != 0) {
+      sheenRoughness *= textureSample(
+        pbr_sheenRoughnessSampler,
+        pbr_sheenRoughnessSamplerSampler,
+        fragmentInputs.pbr_vUV
+      ).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,
+        fragmentInputs.pbr_vUV
+      ).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,
+        fragmentInputs.pbr_vUV
+      ).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,
+        fragmentInputs.pbr_vUV
+      ).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 +19083,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 +19105,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 +19143,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,7 +19179,16 @@ 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
 
@@ -17652,14 +19201,19 @@ fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
     }
     #endif
 
+    var emissive = pbrMaterial.emissiveFactor;
     #ifdef HAS_EMISSIVEMAP
     if (pbrMaterial.emissiveMapEnabled != 0u) {
-      let emissive = SRGBtoLINEAR(
+      emissive *= SRGBtoLINEAR(
         textureSample(pbr_emissiveSampler, pbr_emissiveSamplerSampler, fragmentInputs.pbr_vUV)
-      ).rgb * pbrMaterial.emissiveFactor;
-      color += emissive;
+      ).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 +19232,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 +19241,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 +19258,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 +19281,75 @@ 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
+    },
     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 +19363,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 +19398,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 +19411,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 +19424,15 @@ 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>"
     }
   };
 
@@ -17810,7 +19441,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;
 `;
@@ -28254,6 +29885,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;
@@ -31612,17 +33251,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 });
     }