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

package/src/parsers/parse-pbr-material.ts

@@ -4,12 +4,12 @@
 
 import type {Device, SamplerProps, TextureFormat, TypedArray} from '@luma.gl/core';
 import {Texture, log, textureFormatDecoder} from '@luma.gl/core';
-import type {GLTFSampler} from '@loaders.gl/gltf';
-import {GL} from '@luma.gl/constants';
+import type {GLTFPostprocessed, GLTFSampler} from '@loaders.gl/gltf';
 
 import {type ParsedPBRMaterial} from '../pbr/pbr-material';
 import {type PBREnvironment} from '../pbr/pbr-environment';
 import {type PBRMaterialBindings} from '@luma.gl/shadertools';
+import {GLEnum} from '../webgl-to-webgpu/gltf-webgl-constants';
 import {convertSampler} from '../webgl-to-webgpu/convert-webgl-sampler';
 
 // TODO - synchronize the GLTF... types with loaders.gl
@@ -19,6 +19,7 @@ import {convertSampler} from '../webgl-to-webgpu/convert-webgl-sampler';
 
 type GLTFTexture = {
   id: string;
+  index?: number;
   texture: {source: {image: any}; sampler: {parameters: any}};
   uniformName?: string;
   // is this on all textures?
@@ -36,16 +37,114 @@ type GLTFPBRMetallicRoughness = {
 };
 
 type GLTFPBRMaterial = {
+  extensions?: GLTFMaterialExtensions;
   unlit?: boolean;
   pbrMetallicRoughness?: GLTFPBRMetallicRoughness;
   normalTexture?: GLTFTexture;
   occlusionTexture?: GLTFTexture;
   emissiveTexture?: GLTFTexture;
   emissiveFactor?: [number, number, number];
-  alphaMode?: 'MASK' | 'BLEND';
+  alphaMode?: 'OPAQUE' | 'MASK' | 'BLEND';
+  doubleSided?: boolean;
   alphaCutoff?: number;
 };
 
+type GLTFMaterialSpecularExtension = {
+  specularFactor?: number;
+  specularTexture?: GLTFTexture;
+  specularColorFactor?: [number, number, number];
+  specularColorTexture?: GLTFTexture;
+};
+
+type GLTFMaterialIorExtension = {
+  ior?: number;
+};
+
+type GLTFMaterialTransmissionExtension = {
+  transmissionFactor?: number;
+  transmissionTexture?: GLTFTexture;
+};
+
+type GLTFMaterialVolumeExtension = {
+  thicknessFactor?: number;
+  thicknessTexture?: GLTFTexture;
+  attenuationDistance?: number;
+  attenuationColor?: [number, number, number];
+};
+
+type GLTFMaterialClearcoatExtension = {
+  clearcoatFactor?: number;
+  clearcoatTexture?: GLTFTexture;
+  clearcoatRoughnessFactor?: number;
+  clearcoatRoughnessTexture?: GLTFTexture;
+  clearcoatNormalTexture?: GLTFTexture;
+};
+
+type GLTFMaterialSheenExtension = {
+  sheenColorFactor?: [number, number, number];
+  sheenColorTexture?: GLTFTexture;
+  sheenRoughnessFactor?: number;
+  sheenRoughnessTexture?: GLTFTexture;
+};
+
+type GLTFMaterialIridescenceExtension = {
+  iridescenceFactor?: number;
+  iridescenceTexture?: GLTFTexture;
+  iridescenceIor?: number;
+  iridescenceThicknessMinimum?: number;
+  iridescenceThicknessMaximum?: number;
+  iridescenceThicknessTexture?: GLTFTexture;
+};
+
+type GLTFMaterialAnisotropyExtension = {
+  anisotropyStrength?: number;
+  anisotropyRotation?: number;
+  anisotropyTexture?: GLTFTexture;
+};
+
+type GLTFMaterialEmissiveStrengthExtension = {
+  emissiveStrength?: number;
+};
+
+type GLTFMaterialExtensions = {
+  KHR_materials_unlit?: Record<string, never>;
+  KHR_materials_specular?: GLTFMaterialSpecularExtension;
+  KHR_materials_ior?: GLTFMaterialIorExtension;
+  KHR_materials_transmission?: GLTFMaterialTransmissionExtension;
+  KHR_materials_volume?: GLTFMaterialVolumeExtension;
+  KHR_materials_clearcoat?: GLTFMaterialClearcoatExtension;
+  KHR_materials_sheen?: GLTFMaterialSheenExtension;
+  KHR_materials_iridescence?: GLTFMaterialIridescenceExtension;
+  KHR_materials_anisotropy?: GLTFMaterialAnisotropyExtension;
+  KHR_materials_emissive_strength?: GLTFMaterialEmissiveStrengthExtension;
+};
+
+type TextureEnabledUniformName =
+  | 'baseColorMapEnabled'
+  | 'normalMapEnabled'
+  | 'emissiveMapEnabled'
+  | 'metallicRoughnessMapEnabled'
+  | 'occlusionMapEnabled'
+  | 'specularColorMapEnabled'
+  | 'specularIntensityMapEnabled'
+  | 'transmissionMapEnabled'
+  | 'clearcoatMapEnabled'
+  | 'clearcoatRoughnessMapEnabled'
+  | 'sheenColorMapEnabled'
+  | 'sheenRoughnessMapEnabled'
+  | 'iridescenceMapEnabled'
+  | 'anisotropyMapEnabled';
+
+type TextureFeatureOptions = {
+  define?: string;
+  enabledUniformName?: TextureEnabledUniformName;
+};
+
+type TextureParseOptions = {
+  featureOptions?: TextureFeatureOptions;
+  gltf?: GLTFPostprocessed;
+};
+
 export type ParsePBRMaterialOptions = {
   /** Debug PBR shader */
   pbrDebug?: boolean;
@@ -55,6 +154,10 @@ export type ParsePBRMaterialOptions = {
   useTangents?: boolean;
   /** provide an image based (texture cube) lighting environment */
   imageBasedLightingEnvironment?: PBREnvironment;
+  /** parent post-processed glTF, used to resolve extension texture infos */
+  gltf?: GLTFPostprocessed;
+  /** run primitive-attribute diagnostics such as missing TEXCOORD_0 / NORMAL */
+  validateAttributes?: boolean;
 };
 
 /**
@@ -93,7 +196,8 @@ export function parsePBRMaterial(
       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];
   }
 
@@ -114,106 +218,217 @@ export function parsePBRMaterial(
   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 warnOnMissingExpectedAttributes(
+  material: GLTFPBRMaterial,
+  attributes: Record<string, any>
+): void {
+  const uvDependentTextureSlots = getUvDependentTextureSlots(material);
+  if (uvDependentTextureSlots.length > 0 && !attributes['TEXCOORD_0']) {
+    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';
+  log.warn(
+    `glTF primitive is missing NORMAL while using ${missingNormalReason}; shading will fall back to geometric normals`
+  )();
+}
+
+function getUvDependentTextureSlots(material: GLTFPBRMaterial): string[] {
+  const uvDependentTextureSlots: string[] = [];
+
+  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;
+}
+
 /** Parse GLTF material record */
 function parseMaterial(
   device: Device,
   material: GLTFPBRMaterial,
-  parsedMaterial: ParsedPBRMaterial
+  parsedMaterial: ParsedPBRMaterial,
+  gltf?: GLTFPostprocessed
 ): void {
-  parsedMaterial.uniforms.unlit = Boolean(material.unlit);
+  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 = 1} = material.normalTexture;
     parsedMaterial.uniforms.normalScale = scale;
   }
   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':
       log.warn('glTF BLEND alphaMode might not work well because it requires mesh sorting')();
-
-      // WebGPU style parameters
-      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';
-
-      // GL parameters
-      // TODO - remove in favor of parameters
-      parsedMaterial.glParameters['blend'] = true;
-      parsedMaterial.glParameters['blendEquation'] = GL.FUNC_ADD;
-      parsedMaterial.glParameters['blendFunc'] = [
-        GL.SRC_ALPHA,
-        GL.ONE_MINUS_SRC_ALPHA,
-        GL.ONE,
-        GL.ONE_MINUS_SRC_ALPHA
-      ];
+      applyAlphaBlendParameters(parsedMaterial);
 
       break;
   }
 }
 
+function applyAlphaBlendParameters(parsedMaterial: ParsedPBRMaterial): void {
+  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: ParsedPBRMaterial): void {
+  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
+  ];
+}
+
 /** Parse GLTF material sub record */
 function parsePbrMetallicRoughness(
   device: Device,
   pbrMetallicRoughness: GLTFPBRMetallicRoughness,
-  parsedMaterial: ParsedPBRMaterial
+  parsedMaterial: ParsedPBRMaterial,
+  gltf?: GLTFPostprocessed
 ): void {
   if (pbrMetallicRoughness.baseColorTexture) {
     addTexture(
       device,
       pbrMetallicRoughness.baseColorTexture,
       'pbr_baseColorSampler',
-      'HAS_BASECOLORMAP',
-      parsedMaterial
+      parsedMaterial,
+      {
+        featureOptions: {
+          define: 'HAS_BASECOLORMAP',
+          enabledUniformName: 'baseColorMapEnabled'
+        },
+        gltf
+      }
     );
   }
   parsedMaterial.uniforms.baseColorFactor = pbrMetallicRoughness.baseColorFactor || [1, 1, 1, 1];
@@ -223,34 +438,374 @@ function parsePbrMetallicRoughness(
       device,
       pbrMetallicRoughness.metallicRoughnessTexture,
       'pbr_metallicRoughnessSampler',
-      'HAS_METALROUGHNESSMAP',
-      parsedMaterial
+      parsedMaterial,
+      {
+        featureOptions: {
+          define: 'HAS_METALROUGHNESSMAP',
+          enabledUniformName: 'metallicRoughnessMapEnabled'
+        },
+        gltf
+      }
     );
   }
   const {metallicFactor = 1, roughnessFactor = 1} = pbrMetallicRoughness;
   parsedMaterial.uniforms.metallicRoughnessValues = [metallicFactor, roughnessFactor];
 }
 
+function parseMaterialExtensions(
+  device: Device,
+  extensions: GLTFMaterialExtensions | undefined,
+  parsedMaterial: ParsedPBRMaterial,
+  gltf?: GLTFPostprocessed
+): void {
+  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: GLTFMaterialExtensions): boolean {
+  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: Device,
+  extension: GLTFMaterialSpecularExtension | undefined,
+  parsedMaterial: ParsedPBRMaterial,
+  gltf?: GLTFPostprocessed
+): void {
+  if (!extension) {
+    return;
+  }
+
+  if (extension.specularColorFactor) {
+    parsedMaterial.uniforms.specularColorFactor = extension.specularColorFactor;
+  }
+  if (extension.specularFactor !== undefined) {
+    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: GLTFMaterialIorExtension | undefined,
+  parsedMaterial: ParsedPBRMaterial
+): void {
+  if (extension?.ior !== undefined) {
+    parsedMaterial.uniforms.ior = extension.ior;
+  }
+}
+
+function parseTransmissionExtension(
+  device: Device,
+  extension: GLTFMaterialTransmissionExtension | undefined,
+  parsedMaterial: ParsedPBRMaterial,
+  gltf?: GLTFPostprocessed
+): void {
+  if (!extension) {
+    return;
+  }
+
+  if (extension.transmissionFactor !== undefined) {
+    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) {
+    log.warn(
+      'KHR_materials_transmission uses a premultiplied-alpha blending approximation and may require mesh sorting'
+    )();
+    applyTransmissionBlendApproximation(parsedMaterial);
+  }
+}
+
+function parseVolumeExtension(
+  device: Device,
+  extension: GLTFMaterialVolumeExtension | undefined,
+  parsedMaterial: ParsedPBRMaterial,
+  gltf?: GLTFPostprocessed
+): void {
+  if (!extension) {
+    return;
+  }
+
+  if (extension.thicknessFactor !== undefined) {
+    parsedMaterial.uniforms.thicknessFactor = extension.thicknessFactor;
+  }
+  if (extension.thicknessTexture) {
+    addTexture(device, extension.thicknessTexture, 'pbr_thicknessSampler', parsedMaterial, {
+      featureOptions: {
+        define: 'HAS_THICKNESSMAP'
+      },
+      gltf
+    });
+  }
+  if (extension.attenuationDistance !== undefined) {
+    parsedMaterial.uniforms.attenuationDistance = extension.attenuationDistance;
+  }
+  if (extension.attenuationColor) {
+    parsedMaterial.uniforms.attenuationColor = extension.attenuationColor;
+  }
+}
+
+function parseClearcoatExtension(
+  device: Device,
+  extension: GLTFMaterialClearcoatExtension | undefined,
+  parsedMaterial: ParsedPBRMaterial,
+  gltf?: GLTFPostprocessed
+): void {
+  if (!extension) {
+    return;
+  }
+
+  if (extension.clearcoatFactor !== undefined) {
+    parsedMaterial.uniforms.clearcoatFactor = extension.clearcoatFactor;
+  }
+  if (extension.clearcoatRoughnessFactor !== undefined) {
+    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: Device,
+  extension: GLTFMaterialSheenExtension | undefined,
+  parsedMaterial: ParsedPBRMaterial,
+  gltf?: GLTFPostprocessed
+): void {
+  if (!extension) {
+    return;
+  }
+
+  if (extension.sheenColorFactor) {
+    parsedMaterial.uniforms.sheenColorFactor = extension.sheenColorFactor;
+  }
+  if (extension.sheenRoughnessFactor !== undefined) {
+    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: Device,
+  extension: GLTFMaterialIridescenceExtension | undefined,
+  parsedMaterial: ParsedPBRMaterial,
+  gltf?: GLTFPostprocessed
+): void {
+  if (!extension) {
+    return;
+  }
+
+  if (extension.iridescenceFactor !== undefined) {
+    parsedMaterial.uniforms.iridescenceFactor = extension.iridescenceFactor;
+  }
+  if (extension.iridescenceIor !== undefined) {
+    parsedMaterial.uniforms.iridescenceIor = extension.iridescenceIor;
+  }
+  if (
+    extension.iridescenceThicknessMinimum !== undefined ||
+    extension.iridescenceThicknessMaximum !== undefined
+  ) {
+    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: Device,
+  extension: GLTFMaterialAnisotropyExtension | undefined,
+  parsedMaterial: ParsedPBRMaterial,
+  gltf?: GLTFPostprocessed
+): void {
+  if (!extension) {
+    return;
+  }
+
+  if (extension.anisotropyStrength !== undefined) {
+    parsedMaterial.uniforms.anisotropyStrength = extension.anisotropyStrength;
+  }
+  if (extension.anisotropyRotation !== undefined) {
+    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: GLTFMaterialEmissiveStrengthExtension | undefined,
+  parsedMaterial: ParsedPBRMaterial
+): void {
+  if (extension?.emissiveStrength !== undefined) {
+    parsedMaterial.uniforms.emissiveStrength = extension.emissiveStrength;
+  }
+}
+
 /** Create a texture from a glTF texture/sampler/image combo and add it to bindings */
 function addTexture(
   device: Device,
   gltfTexture: GLTFTexture,
   uniformName: keyof PBRMaterialBindings,
-  define: string,
-  parsedMaterial: ParsedPBRMaterial
+  parsedMaterial: ParsedPBRMaterial,
+  textureParseOptions: TextureParseOptions = {}
 ): void {
-  const image = gltfTexture.texture.source.image;
+  const {featureOptions = {}, gltf} = textureParseOptions;
+  const {define, enabledUniformName} = featureOptions;
+  const resolvedTextureInfo = resolveTextureInfo(gltfTexture, gltf);
+  const image = resolvedTextureInfo.texture?.source?.image;
+  if (!image) {
+    log.warn(`Skipping unresolved glTF texture for ${String(uniformName)}`)();
+    return;
+  }
 
   const gltfSampler = {
     wrapS: 10497, // default REPEAT S (U) wrapping mode.
     wrapT: 10497, // default REPEAT T (V) wrapping mode.
     minFilter: 9729, // default LINEAR filtering
     magFilter: 9729, // default LINEAR filtering
-    ...gltfTexture?.texture?.sampler
+    ...resolvedTextureInfo?.texture?.sampler
   } as GLTFSampler;
 
   const baseOptions = {
-    id: gltfTexture.uniformName || gltfTexture.id,
+    id: resolvedTextureInfo.uniformName || resolvedTextureInfo.id,
     sampler: convertSampler(gltfSampler)
   };
 
@@ -270,9 +825,43 @@ function addTexture(
 
   parsedMaterial.bindings[uniformName] = texture;
   if (define) parsedMaterial.defines[define] = true;
+  if (enabledUniformName) {
+    parsedMaterial.uniforms[enabledUniformName] = true;
+  }
   parsedMaterial.generatedTextures.push(texture);
 }
 
+function resolveTextureInfo(gltfTexture: GLTFTexture, gltf?: GLTFPostprocessed): GLTFTexture {
+  if (gltfTexture.texture || gltfTexture.index === undefined || !gltf?.textures) {
+    return gltfTexture;
+  }
+
+  const resolvedTextureEntry = gltf.textures[gltfTexture.index] as
+    | Partial<GLTFTexture>
+    | GLTFTexture['texture']
+    | undefined;
+  if (!resolvedTextureEntry) {
+    return gltfTexture;
+  }
+
+  if ('texture' in resolvedTextureEntry && resolvedTextureEntry.texture) {
+    return {
+      ...resolvedTextureEntry,
+      ...gltfTexture,
+      texture: resolvedTextureEntry.texture
+    } as GLTFTexture;
+  }
+
+  if (!('source' in resolvedTextureEntry)) {
+    return gltfTexture;
+  }
+
+  return {
+    ...gltfTexture,
+    texture: resolvedTextureEntry
+  };
+}
+
 /** One mip level as produced by loaders.gl compressed texture parsers */
 export type CompressedMipLevel = {
   data: TypedArray;
@@ -502,7 +1091,7 @@ export class PBRMaterialParser {
     if (imageBasedLightingEnvironment) {
       this.bindings.pbr_diffuseEnvSampler = imageBasedLightingEnvironment.getDiffuseEnvSampler();
       this.bindings.pbr_specularEnvSampler = imageBasedLightingEnvironment.getSpecularEnvSampler();
-      this.bindings.pbr_BrdfLUT = imageBasedLightingEnvironment.getBrdfTexture();
+      this.bindings.pbr_brdfLUT = imageBasedLightingEnvironment.getBrdfTexture();
       this.uniforms.scaleIBLAmbient = [1, 1];
     }
 
@@ -572,8 +1161,13 @@ export class PBRMaterialParser {
       log.warn('BLEND alphaMode might not work well because it requires mesh sorting')();
       Object.assign(this.parameters, {
         blend: true,
-        blendEquation: GL.FUNC_ADD,
-        blendFunc: [GL.SRC_ALPHA, GL.ONE_MINUS_SRC_ALPHA, GL.ONE, GL.ONE_MINUS_SRC_ALPHA]
+        blendEquation: GLEnum.FUNC_ADD,
+        blendFunc: [
+          GLEnum.SRC_ALPHA,
+          GLEnum.ONE_MINUS_SRC_ALPHA,
+          GLEnum.ONE,
+          GLEnum.ONE_MINUS_SRC_ALPHA
+        ]
       });
     }
   }
@@ -610,7 +1204,8 @@ export class PBRMaterialParser {
     if (image.compressed) {
       textureOptions = image;
       specialTextureParameters = {
-        [GL.TEXTURE_MIN_FILTER]: image.data.length > 1 ? GL.LINEAR_MIPMAP_NEAREST : GL.LINEAR
+        [GLEnum.TEXTURE_MIN_FILTER]:
+          image.data.length > 1 ? GLEnum.LINEAR_MIPMAP_NEAREST : GLEnum.LINEAR
       };
     } else {
       // Texture2D accepts a promise that returns an image as data (Async Textures)
@@ -624,7 +1219,7 @@ export class PBRMaterialParser {
         ...specialTextureParameters
       },
       pixelStore: {
-        [GL.UNPACK_FLIP_Y_WEBGL]: false
+        [GLEnum.UNPACK_FLIP_Y_WEBGL]: false
       },
       ...textureOptions
     });