@luma.gl/shaders 0.0.0-stage → 10.0.0-alpha.6

package/src/modules/lighting/pbr-material/pbr-material-wgsl.ts

@@ -0,0 +1,2043 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileCopyrightText: Copyright (c) 2016-2017 Mohamad Moneimne and Contributors
+
+// Attribution:
+// MIT license, Copyright (c) 2016-2017 Mohamad Moneimne and Contributors
+// This fragment shader defines a reference implementation for Physically Based Shading of
+// a microfacet surface material defined by a glTF model.
+
+// TODO - better do the checks outside of shader
+
+export const pbrMaterialUniforms = /* wgsl */ `\
+uniform Projection {
+  // Projection
+  vec3 u_Camera;
+};
+
+uniform pbrMaterialUniforms {
+  // Material is unlit
+  bool unlit;
+
+  // Base color map
+  bool baseColorMapEnabled;
+  vec4 baseColorFactor;
+
+  bool normalMapEnabled;  
+  float normalScale; // #ifdef HAS_NORMALMAP
+
+  bool emissiveMapEnabled;
+  bool lightmapMapEnabled;
+  vec3 emissiveFactor; // #ifdef HAS_EMISSIVEMAP
+
+  vec2 metallicRoughnessValues;
+  bool metallicRoughnessMapEnabled;
+
+  bool occlusionMapEnabled;
+  float occlusionStrength; // #ifdef HAS_OCCLUSIONMAP
+  
+  bool alphaCutoffEnabled;
+  float alphaCutoff; // #ifdef ALPHA_CUTOFF
+
+  vec3 specularColorFactor;
+  float specularIntensityFactor;
+  bool specularColorMapEnabled;
+  bool specularIntensityMapEnabled;
+
+  float ior;
+
+  float transmissionFactor;
+  bool transmissionMapEnabled;
+
+  float thicknessFactor;
+  float attenuationDistance;
+  vec3 attenuationColor;
+
+  float clearcoatFactor;
+  float clearcoatRoughnessFactor;
+  bool clearcoatMapEnabled;
+  bool clearcoatRoughnessMapEnabled;
+
+  vec3 sheenColorFactor;
+  float sheenRoughnessFactor;
+  bool sheenColorMapEnabled;
+  bool sheenRoughnessMapEnabled;
+
+  float iridescenceFactor;
+  float iridescenceIor;
+  vec2 iridescenceThicknessRange;
+  bool iridescenceMapEnabled;
+
+  float anisotropyStrength;
+  float anisotropyRotation;
+  vec2 anisotropyDirection;
+  bool anisotropyMapEnabled;
+
+  float emissiveStrength;
+  float lightmapIntensity;
+  float dispersion;
+  
+  // IBL
+  bool IBLenabled;
+  vec2 scaleIBLAmbient; // #ifdef USE_IBL
+  
+  // debugging flags used for shader output of intermediate PBR variables
+  // #ifdef PBR_DEBUG
+  vec4 scaleDiffBaseMR;
+  vec4 scaleFGDSpec;
+  // #endif
+};
+
+// Samplers
+#ifdef HAS_BASECOLORMAP
+uniform sampler2D u_BaseColorSampler;
+#endif
+#ifdef HAS_NORMALMAP
+uniform sampler2D u_NormalSampler;
+#endif
+#ifdef HAS_EMISSIVEMAP
+uniform sampler2D u_EmissiveSampler;
+#endif
+#ifdef HAS_LIGHTMAP
+uniform sampler2D u_LightmapSampler;
+#endif
+#ifdef HAS_METALROUGHNESSMAP
+uniform sampler2D u_MetallicRoughnessSampler;
+#endif
+#ifdef HAS_OCCLUSIONMAP
+uniform sampler2D u_OcclusionSampler;
+#endif
+#ifdef HAS_SPECULARCOLORMAP
+uniform sampler2D u_SpecularColorSampler;
+#endif
+#ifdef HAS_SPECULARINTENSITYMAP
+uniform sampler2D u_SpecularIntensitySampler;
+#endif
+#ifdef HAS_TRANSMISSIONMAP
+uniform sampler2D u_TransmissionSampler;
+#endif
+#ifdef HAS_THICKNESSMAP
+uniform sampler2D u_ThicknessSampler;
+#endif
+#ifdef HAS_CLEARCOATMAP
+uniform sampler2D u_ClearcoatSampler;
+#endif
+#ifdef HAS_CLEARCOATROUGHNESSMAP
+uniform sampler2D u_ClearcoatRoughnessSampler;
+#endif
+#ifdef HAS_CLEARCOATNORMALMAP
+uniform sampler2D u_ClearcoatNormalSampler;
+#endif
+#ifdef HAS_SHEENCOLORMAP
+uniform sampler2D u_SheenColorSampler;
+#endif
+#ifdef HAS_SHEENROUGHNESSMAP
+uniform sampler2D u_SheenRoughnessSampler;
+#endif
+#ifdef HAS_IRIDESCENCEMAP
+uniform sampler2D u_IridescenceSampler;
+#endif
+#ifdef HAS_IRIDESCENCETHICKNESSMAP
+uniform sampler2D u_IridescenceThicknessSampler;
+#endif
+#ifdef HAS_ANISOTROPYMAP
+uniform sampler2D u_AnisotropySampler;
+#endif
+#ifdef USE_IBL
+uniform samplerCube u_DiffuseEnvSampler;
+uniform samplerCube u_SpecularEnvSampler;
+uniform sampler2D u_brdfLUT;
+#endif
+
+`;
+
+export const source = /* wgsl */ `\
+#ifdef DOUBLE_SIDED
+var<private> pbr_frontFacing: bool = true;
+#endif
+struct PBRFragmentInputs {
+  pbr_vPosition: vec3f,
+  pbr_vUV0: vec2f,
+  pbr_vUV1: vec2f,
+  pbr_vTBN: mat3x3f,
+  pbr_vNormal: vec3f
+};
+
+var<private> fragmentInputs: PBRFragmentInputs;
+
+fn pbr_setPositionNormalTangentUV(
+  position: vec4f,
+  normal: vec4f,
+  tangent: vec4f,
+  uv0: vec2f,
+  uv1: vec2f
+)
+{
+  var pos: vec4f = pbrProjection.modelMatrix * position;
+  fragmentInputs.pbr_vPosition = pos.xyz / pos.w;
+  fragmentInputs.pbr_vNormal = vec3f(0.0, 0.0, 1.0);
+  fragmentInputs.pbr_vTBN = mat3x3f(
+    vec3f(1.0, 0.0, 0.0),
+    vec3f(0.0, 1.0, 0.0),
+    vec3f(0.0, 0.0, 1.0)
+  );
+  fragmentInputs.pbr_vUV0 = vec2f(0.0, 0.0);
+  fragmentInputs.pbr_vUV1 = uv1;
+
+#ifdef HAS_NORMALS
+  let normalW: vec3f = normalize((pbrProjection.normalMatrix * vec4f(normal.xyz, 0.0)).xyz);
+  fragmentInputs.pbr_vNormal = normalW;
+#ifdef HAS_TANGENTS
+  let tangentW: vec3f = normalize((pbrProjection.modelMatrix * vec4f(tangent.xyz, 0.0)).xyz);
+  let bitangentW: vec3f = cross(normalW, tangentW) * tangent.w;
+  fragmentInputs.pbr_vTBN = mat3x3f(tangentW, bitangentW, normalW);
+#endif
+#endif
+
+#ifdef HAS_UV
+  fragmentInputs.pbr_vUV0 = uv0;
+#endif
+}
+
+struct pbrMaterialUniforms {
+  // Material is unlit
+  unlit: u32,
+
+  // Base color map
+  baseColorMapEnabled: u32,
+  baseColorFactor: vec4f,
+
+  normalMapEnabled : u32,
+  normalScale: f32,  // #ifdef HAS_NORMALMAP
+
+  emissiveMapEnabled: u32,
+  emissiveFactor: vec3f, // #ifdef HAS_EMISSIVEMAP
+
+  metallicRoughnessValues: vec2f,
+  metallicRoughnessMapEnabled: u32,
+
+  occlusionMapEnabled: i32,
+  occlusionStrength: f32, // #ifdef HAS_OCCLUSIONMAP
+  
+  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,
+  dispersion: f32,
+  
+  // IBL
+  IBLenabled: i32,
+  scaleIBLAmbient: vec2f, // #ifdef USE_IBL
+  
+  // debugging flags used for shader output of intermediate PBR variables
+  // #ifdef PBR_DEBUG
+  scaleDiffBaseMR: vec4f,
+  scaleFGDSpec: vec4f,
+  // #endif
+
+  baseColorUVSet: i32,
+  baseColorUVTransform: mat3x3f,
+  metallicRoughnessUVSet: i32,
+  metallicRoughnessUVTransform: mat3x3f,
+  normalUVSet: i32,
+  normalUVTransform: mat3x3f,
+  occlusionUVSet: i32,
+  occlusionUVTransform: mat3x3f,
+  emissiveUVSet: i32,
+  emissiveUVTransform: mat3x3f,
+  specularColorUVSet: i32,
+  specularColorUVTransform: mat3x3f,
+  specularIntensityUVSet: i32,
+  specularIntensityUVTransform: mat3x3f,
+  transmissionUVSet: i32,
+  transmissionUVTransform: mat3x3f,
+  thicknessUVSet: i32,
+  thicknessUVTransform: mat3x3f,
+  clearcoatUVSet: i32,
+  clearcoatUVTransform: mat3x3f,
+  clearcoatRoughnessUVSet: i32,
+  clearcoatRoughnessUVTransform: mat3x3f,
+  clearcoatNormalUVSet: i32,
+  clearcoatNormalUVTransform: mat3x3f,
+  sheenColorUVSet: i32,
+  sheenColorUVTransform: mat3x3f,
+  sheenRoughnessUVSet: i32,
+  sheenRoughnessUVTransform: mat3x3f,
+  iridescenceUVSet: i32,
+  iridescenceUVTransform: mat3x3f,
+  iridescenceThicknessUVSet: i32,
+  iridescenceThicknessUVTransform: mat3x3f,
+  anisotropyUVSet: i32,
+  anisotropyUVTransform: mat3x3f,
+
+  bumpFactor: f32,
+  bumpMapEnabled: i32,
+  diffuseTransmissionFactor: f32,
+  diffuseTransmissionMapEnabled: i32,
+  diffuseTransmissionColorFactor: vec3f,
+  diffuseTransmissionColorMapEnabled: i32,
+  multiscatterColorFactor: vec3f,
+  multiscatterColorMapEnabled: i32,
+  scatterAnisotropy: f32,
+
+  bumpUVSet: i32,
+  bumpUVTransform: mat3x3f,
+  diffuseTransmissionUVSet: i32,
+  diffuseTransmissionUVTransform: mat3x3f,
+  diffuseTransmissionColorUVSet: i32,
+  diffuseTransmissionColorUVTransform: mat3x3f,
+  multiscatterColorUVSet: i32,
+  multiscatterColorUVTransform: mat3x3f,
+  lightmapMapEnabled: u32,
+  lightmapIntensity: f32,
+  lightmapUVSet: i32,
+  lightmapUVTransform: mat3x3f,
+  scatterStrengthFactor: f32,
+}
+
+@group(3) @binding(auto) var<uniform> pbrMaterial : pbrMaterialUniforms;
+
+// Samplers
+#ifdef HAS_BASECOLORMAP
+@group(3) @binding(auto) var pbr_baseColorSampler: texture_2d<f32>;
+@group(3) @binding(auto) var pbr_baseColorSamplerSampler: sampler;
+#endif
+#ifdef HAS_NORMALMAP
+@group(3) @binding(auto) var pbr_normalSampler: texture_2d<f32>;
+@group(3) @binding(auto) var pbr_normalSamplerSampler: sampler;
+#endif
+#ifdef HAS_EMISSIVEMAP
+@group(3) @binding(auto) var pbr_emissiveSampler: texture_2d<f32>;
+@group(3) @binding(auto) var pbr_emissiveSamplerSampler: sampler;
+#endif
+#ifdef HAS_LIGHTMAP
+@group(3) @binding(auto) var pbr_lightmapSampler: texture_2d<f32>;
+@group(3) @binding(auto) var pbr_lightmapSamplerSampler: sampler;
+#endif
+#ifdef HAS_METALROUGHNESSMAP
+@group(3) @binding(auto) var pbr_metallicRoughnessSampler: texture_2d<f32>;
+@group(3) @binding(auto) var pbr_metallicRoughnessSamplerSampler: sampler;
+#endif
+#ifdef HAS_OCCLUSIONMAP
+@group(3) @binding(auto) var pbr_occlusionSampler: texture_2d<f32>;
+@group(3) @binding(auto) var pbr_occlusionSamplerSampler: sampler;
+#endif
+#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
+#ifdef HAS_BUMPMAP
+@group(3) @binding(auto) var pbr_bumpSampler: texture_2d<f32>;
+@group(3) @binding(auto) var pbr_bumpSamplerSampler: sampler;
+#endif
+#ifdef HAS_DIFFUSETRANSMISSIONMAP
+@group(3) @binding(auto) var pbr_diffuseTransmissionSampler: texture_2d<f32>;
+@group(3) @binding(auto) var pbr_diffuseTransmissionSamplerSampler: sampler;
+#endif
+#ifdef HAS_DIFFUSETRANSMISSIONCOLORMAP
+@group(3) @binding(auto) var pbr_diffuseTransmissionColorSampler: texture_2d<f32>;
+@group(3) @binding(auto) var pbr_diffuseTransmissionColorSamplerSampler: sampler;
+#endif
+#ifdef HAS_MULTISCATTERCOLORMAP
+@group(3) @binding(auto) var pbr_multiscatterColorSampler: texture_2d<f32>;
+@group(3) @binding(auto) var pbr_multiscatterColorSamplerSampler: 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.
+struct PBRInfo {
+  NdotL: f32,                  // cos angle between normal and light direction
+  NdotV: f32,                  // cos angle between normal and view direction
+  NdotH: f32,                  // cos angle between normal and half vector
+  LdotH: f32,                  // cos angle between light direction and half vector
+  VdotH: f32,                  // cos angle between view direction and half vector
+  perceptualRoughness: f32,    // roughness value, as authored by the model creator (input to shader)
+  metalness: f32,              // metallic value at the surface
+  reflectance0: vec3f,            // full reflectance color (normal incidence angle)
+  reflectance90: vec3f,           // reflectance color at grazing angle
+  alphaRoughness: f32,         // roughness mapped to a more linear change in the roughness (proposed by [2])
+  diffuseColor: vec3f,            // color contribution from diffuse lighting
+  specularColor: vec3f,           // color contribution from specular lighting
+  n: vec3f,                       // normal at surface point
+  v: vec3f,                       // vector from surface point to camera
+  l: vec3f,                       // direction from the surface toward the current light
+  h: vec3f                        // half vector between the current light and camera
+};
+
+const M_PI = 3.141592653589793;
+const c_MinRoughness = 0.04;
+
+// Widen sub-pixel specular lobes using the screen-space normal footprint.
+// This is geometric specular antialiasing: the normal variance is converted
+// into an additional squared perceptual roughness before evaluating BRDFs.
+fn widenSpecularRoughness(perceptualRoughness: f32, normal: vec3f) -> f32 {
+  let normalDerivativeX = dpdx(normal);
+  let normalDerivativeY = dpdy(normal);
+  let normalVariance =
+    dot(normalDerivativeX, normalDerivativeX) +
+    dot(normalDerivativeY, normalDerivativeY);
+  let kernelRoughnessSquared = min(2.0 * normalVariance, 1.0);
+  return clamp(
+    sqrt(perceptualRoughness * perceptualRoughness + kernelRoughnessSquared),
+    c_MinRoughness,
+    1.0
+  );
+}
+
+fn SRGBtoLINEAR(srgbIn: vec4f ) -> vec4f
+{
+  var linOut: vec3f = srgbIn.xyz;
+#ifdef MANUAL_SRGB
+  let bLess: vec3f = step(vec3f(0.04045), srgbIn.xyz);
+  linOut = mix(
+    srgbIn.xyz / vec3f(12.92),
+    pow((srgbIn.xyz + vec3f(0.055)) / vec3f(1.055), vec3f(2.4)),
+    bLess
+  );
+#ifdef SRGB_FAST_APPROXIMATION
+  linOut = pow(srgbIn.xyz, vec3f(2.2));
+#endif
+#endif
+  return vec4f(linOut, srgbIn.w);
+}
+
+fn getMaterialUV(uvSet: i32, uvTransform: mat3x3f) -> vec2f
+{
+  var baseUV = fragmentInputs.pbr_vUV0;
+  if (uvSet == 1) {
+    baseUV = fragmentInputs.pbr_vUV1;
+  }
+  return (uvTransform * vec3f(baseUV, 1.0)).xy;
+}
+
+// Build the tangent basis from interpolated attributes or screen-space derivatives.
+fn getTBN(uv: vec2f) -> mat3x3f
+{
+  let pos_dx: vec3f = dpdx(fragmentInputs.pbr_vPosition);
+  let pos_dy: vec3f = dpdy(fragmentInputs.pbr_vPosition);
+  let tex_dx: vec3f = dpdx(vec3f(uv, 0.0));
+  let tex_dy: vec3f = dpdy(vec3f(uv, 0.0));
+  var t: vec3f = (tex_dy.y * pos_dx - tex_dx.y * pos_dy) / (tex_dx.x * tex_dy.y - tex_dy.x * tex_dx.y);
+
+  var ng: vec3f = cross(pos_dy, pos_dx);
+#ifdef HAS_NORMALS
+  ng = normalize(fragmentInputs.pbr_vNormal);
+#endif
+  t = normalize(t - ng * dot(ng, t));
+  var b: vec3f = normalize(cross(ng, t));
+  var tbn: mat3x3f = mat3x3f(t, b, ng);
+#ifdef HAS_TANGENTS
+  tbn = fragmentInputs.pbr_vTBN;
+#endif
+
+#ifdef DOUBLE_SIDED
+#ifdef HAS_NORMALS
+  // Derivative normals already face the viewer; only flip an authored basis.
+  if (!pbr_frontFacing) { tbn = mat3x3f(-tbn[0], -tbn[1], -tbn[2]); }
+#endif
+#endif
+  return tbn;
+}
+
+// Find the normal for this fragment, pulling either from a predefined normal map
+// or from the interpolated mesh normal and tangent attributes.
+fn getMappedNormal(
+  normalSampler: texture_2d<f32>,
+  normalSamplerBinding: sampler,
+  tbn: mat3x3f,
+  normalScale: f32,
+  uv: vec2f
+) -> vec3f
+{
+  let n = textureSample(normalSampler, normalSamplerBinding, uv).rgb;
+  return normalize(tbn * ((2.0 * n - 1.0) * vec3f(normalScale, normalScale, 1.0)));
+}
+
+fn getNormal(tbn: mat3x3f, uv: vec2f) -> vec3f
+{
+  // The tbn matrix is linearly interpolated, so we need to re-normalize
+  var n: vec3f = normalize(tbn[2].xyz);
+#ifdef HAS_NORMALMAP
+  n = getMappedNormal(
+    pbr_normalSampler,
+    pbr_normalSamplerSampler,
+    tbn,
+    pbrMaterial.normalScale,
+    uv
+  );
+#endif
+
+#ifdef HAS_BUMPMAP
+  let bumpUV = getMaterialUV(pbrMaterial.bumpUVSet, pbrMaterial.bumpUVTransform);
+  let bumpTexelSize = 1.0 / vec2f(textureDimensions(pbr_bumpSampler, 0));
+  let bumpHeight = textureSample(pbr_bumpSampler, pbr_bumpSamplerSampler, bumpUV).r;
+  let bumpGradient = vec2f(
+    textureSample(
+      pbr_bumpSampler,
+      pbr_bumpSamplerSampler,
+      bumpUV + vec2f(bumpTexelSize.x, 0.0)
+    ).r - bumpHeight,
+    textureSample(
+      pbr_bumpSampler,
+      pbr_bumpSamplerSampler,
+      bumpUV + vec2f(0.0, bumpTexelSize.y)
+    ).r - bumpHeight
+  );
+  n = normalize(n - pbrMaterial.bumpFactor *
+    (tbn[0] * bumpGradient.x + tbn[1] * bumpGradient.y));
+#endif
+
+  return n;
+}
+
+fn getClearcoatNormal(tbn: mat3x3f, baseNormal: vec3f, uv: vec2f) -> vec3f
+{
+#ifdef HAS_CLEARCOATNORMALMAP
+  return getMappedNormal(
+    pbr_clearcoatNormalSampler,
+    pbr_clearcoatNormalSamplerSampler,
+    tbn,
+    1.0,
+    uv
+  );
+#else
+  return baseNormal;
+#endif
+}
+
+// Calculation of the lighting contribution from an optional Image Based Light source.
+// Precomputed Environment Maps are required uniform inputs and are computed as outlined in [1].
+// See our README.md on Environment Maps [3] for additional discussion.
+#ifdef USE_IBL
+fn getIBLContribution(pbrInfo: PBRInfo, n: vec3f, reflection: vec3f) -> vec3f
+{
+#ifdef USE_SCENE_ENVIRONMENT
+  let maximumMipLevel = max(pbrScene.environmentMipCount - 1.0, 0.0);
+  let rotationSine = sin(pbrScene.environmentRotation);
+  let rotationCosine = cos(pbrScene.environmentRotation);
+  let environmentRotation = mat2x2f(
+    vec2f(rotationCosine, rotationSine),
+    vec2f(-rotationSine, rotationCosine)
+  );
+  let rotatedNormal = environmentRotation * n.xz;
+  let rotatedReflection = environmentRotation * reflection.xz;
+  let environmentNormal = vec3f(rotatedNormal.x, n.y, rotatedNormal.y);
+  let environmentReflection = vec3f(rotatedReflection.x, reflection.y, rotatedReflection.y);
+#else
+  let maximumMipLevel = 9.0;
+  let environmentNormal = n;
+  let environmentReflection = reflection;
+#endif
+  let lod = pbrInfo.perceptualRoughness * maximumMipLevel;
+  // retrieve a scale and bias to F0. See [1], Figure 3
+  let brdfSample = textureSampleLevel(
+    pbr_brdfLUT,
+    pbr_brdfLUTSampler,
+    vec2f(pbrInfo.NdotV, 1.0 - pbrInfo.perceptualRoughness),
+    0.0
+  );
+  let diffuseSample = textureSampleLevel(
+    pbr_diffuseEnvSampler,
+    pbr_diffuseEnvSamplerSampler,
+    environmentNormal,
+    0.0
+  );
+  var specularSample = textureSampleLevel(
+    pbr_specularEnvSampler,
+    pbr_specularEnvSamplerSampler,
+    environmentReflection,
+    0.0
+  );
+#ifdef USE_TEX_LOD
+  specularSample = textureSampleLevel(
+    pbr_specularEnvSampler,
+    pbr_specularEnvSamplerSampler,
+    environmentReflection,
+    lod
+  );
+#endif
+
+#ifdef USE_SCENE_ENVIRONMENT
+  let brdf = brdfSample.rgb;
+  let diffuseLight = diffuseSample.rgb;
+  let specularLight = specularSample.rgb;
+#else
+  let brdf = SRGBtoLINEAR(brdfSample).rgb;
+  let diffuseLight = SRGBtoLINEAR(diffuseSample).rgb;
+  let specularLight = SRGBtoLINEAR(specularSample).rgb;
+#endif
+
+  let diffuse = diffuseLight * pbrInfo.diffuseColor * pbrMaterial.scaleIBLAmbient.x;
+  let specular =
+    specularLight * (pbrInfo.specularColor * brdf.x + brdf.y) * pbrMaterial.scaleIBLAmbient.y;
+
+#ifdef USE_SCENE_ENVIRONMENT
+  return (diffuse + specular) * max(pbrScene.environmentIntensity, 0.0);
+#else
+  return diffuse + specular;
+#endif
+}
+#endif
+
+// Basic Lambertian diffuse
+// Implementation from Lambert's Photometria https://archive.org/details/lambertsphotome00lambgoog
+// See also [1], Equation 1
+fn diffuse(pbrInfo: PBRInfo) -> vec3<f32> {
+  return pbrInfo.diffuseColor / M_PI;
+}
+
+// The following equation models the Fresnel reflectance term of the spec equation (aka F())
+// Implementation of fresnel from [4], Equation 15
+fn specularReflection(pbrInfo: PBRInfo) -> vec3<f32> {
+  return pbrInfo.reflectance0 +
+    (pbrInfo.reflectance90 - pbrInfo.reflectance0) *
+    pow(clamp(1.0 - pbrInfo.VdotH, 0.0, 1.0), 5.0);
+}
+
+// This calculates the specular geometric attenuation (aka G()),
+// where rougher material will reflect less light back to the viewer.
+// This implementation is based on [1] Equation 4, and we adopt their modifications to
+// alphaRoughness as input as originally proposed in [2].
+fn geometricOcclusion(pbrInfo: PBRInfo) -> f32 {
+  let NdotL: f32 = pbrInfo.NdotL;
+  let NdotV: f32 = pbrInfo.NdotV;
+  let r: f32 = pbrInfo.alphaRoughness;
+
+  let attenuationL = 2.0 * NdotL / (NdotL + sqrt(r * r + (1.0 - r * r) * (NdotL * NdotL)));
+  let attenuationV = 2.0 * NdotV / (NdotV + sqrt(r * r + (1.0 - r * r) * (NdotV * NdotV)));
+  return attenuationL * attenuationV;
+}
+
+// The following equation(s) model the distribution of microfacet normals across
+// the area being drawn (aka D())
+// Implementation from "Average Irregularity Representation of a Roughened Surface
+// for Ray Reflection" by T. S. Trowbridge, and K. P. Reitz
+// Follows the distribution function recommended in the SIGGRAPH 2013 course notes
+// from EPIC Games [1], Equation 3.
+fn microfacetDistribution(pbrInfo: PBRInfo) -> f32 {
+  let roughnessSq = pbrInfo.alphaRoughness * pbrInfo.alphaRoughness;
+  let f = (pbrInfo.NdotH * roughnessSq - pbrInfo.NdotH) * pbrInfo.NdotH + 1.0;
+  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 encodeLinearSRGB(linearColor: vec3f) -> vec3f {
+  let positiveColor = max(linearColor, vec3f(0.0));
+  return select(
+    positiveColor * 12.92,
+    1.055 * pow(positiveColor, vec3f(1.0 / 2.4)) - 0.055,
+    positiveColor > vec3f(0.0031308)
+  );
+}
+
+fn toneMapKhronosPBRNeutral(inputColor: vec3f) -> vec3f {
+  let startCompression = 0.76;
+  let darkestChannel = min(inputColor.r, min(inputColor.g, inputColor.b));
+  let offset = select(
+    0.04,
+    darkestChannel - 6.25 * darkestChannel * darkestChannel,
+    darkestChannel < 0.08
+  );
+  var color = inputColor - vec3f(offset);
+  let peak = maxComponent(color);
+  if (peak < startCompression) {
+    return color;
+  }
+
+  let compressionRange = 1.0 - startCompression;
+  let compressedPeak = 1.0 - compressionRange * compressionRange /
+    (peak + compressionRange - startCompression);
+  color *= compressedPeak / max(peak, 0.0001);
+  let desaturation = 1.0 - 1.0 / (0.15 * (peak - compressedPeak) + 1.0);
+  return mix(color, vec3f(compressedPeak), desaturation);
+}
+
+fn applySceneColorManagement(sceneColor: vec3f) -> vec3f {
+#ifdef USE_SCENE_COLOR_MANAGEMENT
+  var color = max(sceneColor, vec3f(0.0)) * max(pbrScene.exposure, 0.0);
+  if (pbrScene.toneMapMode == 1) {
+    color /= vec3f(1.0) + color;
+  } else if (pbrScene.toneMapMode == 2) {
+    color = toneMapKhronosPBRNeutral(color);
+  } else if (pbrScene.toneMapMode == 3) {
+    color = clamp(
+      (color * (2.51 * color + 0.03)) / (color * (2.43 * color + 0.59) + 0.14),
+      vec3f(0.0),
+      vec3f(1.0)
+    );
+  }
+  if (pbrScene.outputEncoding == 0) {
+    return color;
+  }
+  return encodeLinearSRGB(color);
+#else
+  return pow(max(sceneColor, vec3f(0.0)), vec3f(1.0 / 2.2));
+#endif
+}
+
+fn dielectricSchlick(reflectance: f32, cosine: f32) -> f32 {
+  return reflectance + (1.0 - reflectance) * pow(clamp(1.0 - cosine, 0.0, 1.0), 5.0);
+}
+
+fn evaluateIridescenceSensitivity(opticalPathDifference: f32, phaseShift: vec3f) -> vec3f {
+  let phase = 2.0 * M_PI * opticalPathDifference * 1.0e-9;
+  let sensitivity = vec3f(5.4856e-13, 4.4201e-13, 5.2481e-13);
+  let position = vec3f(1.6810e6, 1.7953e6, 2.2084e6);
+  let variance = vec3f(4.3278e9, 9.3046e9, 6.6121e9);
+  var xyz = sensitivity * sqrt(2.0 * M_PI * variance) *
+    cos(position * phase + phaseShift) * exp(-phase * phase * variance);
+  xyz.x += 9.7470e-14 * sqrt(2.0 * M_PI * 4.5282e9) *
+    cos(2.2399e6 * phase + phaseShift.x) * exp(-4.5282e9 * phase * phase);
+  xyz /= 1.0685e-7;
+  return mat3x3f(
+    vec3f(3.2404542, -0.9692660, 0.0556434),
+    vec3f(-1.5371385, 1.8760108, -0.2040259),
+    vec3f(-0.4985314, 0.0415560, 1.0572252)
+  ) * xyz;
+}
+
+fn getIridescenceTint(
+  iridescence: f32,
+  thickness: f32,
+  NdotV: f32,
+  baseReflectance: vec3f
+) -> vec3f {
+  if (iridescence <= 0.0 || thickness <= 0.0) {
+    return baseReflectance;
+  }
+
+  let filmIor = max(pbrMaterial.iridescenceIor, 1.0);
+  let sineSquared = (1.0 - NdotV * NdotV) / (filmIor * filmIor);
+  let cosineSquared = 1.0 - sineSquared;
+  if (cosineSquared <= 0.0) {
+    return mix(baseReflectance, vec3f(1.0), iridescence);
+  }
+  let filmCosine = sqrt(cosineSquared);
+  let firstInterfaceReflectance = dielectricSchlick(getDielectricF0(filmIor), NdotV);
+  let transmittedEnergy = 1.0 - firstInterfaceReflectance;
+  let squareRootReflectance = sqrt(clamp(baseReflectance, vec3f(0.0), vec3f(0.9999)));
+  let baseIor = (vec3f(1.0) + squareRootReflectance) /
+    (vec3f(1.0) - squareRootReflectance);
+  var secondInterfaceF0 = (baseIor - vec3f(filmIor)) / (baseIor + vec3f(filmIor));
+  secondInterfaceF0 *= secondInterfaceF0;
+  let secondInterfaceReflectance = secondInterfaceF0 +
+    (vec3f(1.0) - secondInterfaceF0) * pow(1.0 - filmCosine, 5.0);
+  let phaseShift = vec3f(M_PI) + select(
+    vec3f(0.0),
+    vec3f(M_PI),
+    baseIor < vec3f(filmIor)
+  );
+  let opticalPathDifference = 2.0 * filmIor * thickness * filmCosine;
+  let combinedReflectance = clamp(
+    firstInterfaceReflectance * secondInterfaceReflectance,
+    vec3f(0.00001),
+    vec3f(0.9999)
+  );
+  let recurringAmplitude = sqrt(combinedReflectance);
+  let interfaceResponse = transmittedEnergy * transmittedEnergy * secondInterfaceReflectance /
+    (vec3f(1.0) - combinedReflectance);
+  var reflectedSpectrum = vec3f(firstInterfaceReflectance) + interfaceResponse;
+  var harmonicAmplitude = interfaceResponse - vec3f(transmittedEnergy);
+  for (var harmonic = 1; harmonic <= 2; harmonic++) {
+    harmonicAmplitude *= recurringAmplitude;
+    reflectedSpectrum += harmonicAmplitude * 2.0 * evaluateIridescenceSensitivity(
+      f32(harmonic) * opticalPathDifference,
+      f32(harmonic) * phaseShift
+    );
+  }
+  return mix(baseReflectance, clamp(reflectedSpectrum, vec3f(0.0), vec3f(1.0)), 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);
+}
+
+// KHR_materials_volume_scatter is an active draft. This evaluates a local,
+// thickness-aware single-scattering approximation rather than random walk.
+fn getDiffuseTransmissionAttenuation(
+  pbrInfo: PBRInfo,
+  multiscatterColor: vec3f,
+  thickness: f32
+) -> vec3f {
+  let volumeAttenuation = getVolumeAttenuation(thickness);
+  let scatteringStrength = maxComponent(multiscatterColor);
+  if (thickness <= 0.0 || scatteringStrength <= 0.0001) {
+    return volumeAttenuation;
+  }
+
+  let anisotropy = clamp(pbrMaterial.scatterAnisotropy, -0.95, 0.95);
+  let scatteringCosine = clamp(dot(-pbrInfo.v, pbrInfo.l), -1.0, 1.0);
+  let phaseDenominator = max(
+    1.0 + anisotropy * anisotropy - 2.0 * anisotropy * scatteringCosine,
+    0.0001
+  );
+  let phaseWeight = clamp(
+    (1.0 - anisotropy * anisotropy) / pow(phaseDenominator, 1.5),
+    0.0,
+    4.0
+  );
+  let scatteringDepth = thickness / max(pbrMaterial.attenuationDistance, 0.0001);
+  let scatteringProbability = 1.0 - exp(-scatteringDepth);
+  let scatteringColor = clamp(multiscatterColor, vec3f(0.0), vec3f(1.0));
+  return mix(
+    volumeAttenuation,
+    volumeAttenuation * mix(vec3f(1.0), scatteringColor * phaseWeight, scatteringColor),
+    scatteringProbability
+  );
+}
+
+fn calculateDiffuseTransmissionLight(
+  pbrInfo: PBRInfo,
+  lightColor: vec3f,
+  diffuseTransmissionColor: vec3f,
+  diffuseTransmission: f32,
+  multiscatterColor: vec3f,
+  thickness: f32
+) -> vec3f {
+  let oppositeHemisphere = max(dot(-pbrInfo.n, pbrInfo.l), 0.0);
+  if (oppositeHemisphere <= 0.0 || diffuseTransmission <= 0.0) {
+    return vec3f(0.0);
+  }
+
+  let nonReflectedEnergy = vec3f(1.0) - clamp(pbrInfo.reflectance0, vec3f(0.0), vec3f(1.0));
+  let attenuatedColor = getDiffuseTransmissionAttenuation(
+    pbrInfo,
+    multiscatterColor,
+    thickness
+  );
+  return lightColor * diffuseTransmissionColor * nonReflectedEnergy *
+    attenuatedColor * (diffuseTransmission * oppositeHemisphere / M_PI);
+}
+
+#ifdef USE_IBL
+fn calculateDiffuseTransmissionIBL(
+  pbrInfo: PBRInfo,
+  diffuseTransmissionColor: vec3f,
+  diffuseTransmission: f32,
+  multiscatterColor: vec3f,
+  thickness: f32
+) -> vec3f {
+  if (diffuseTransmission <= 0.0) {
+    return vec3f(0.0);
+  }
+
+#ifdef USE_SCENE_ENVIRONMENT
+  let rotationSine = sin(pbrScene.environmentRotation);
+  let rotationCosine = cos(pbrScene.environmentRotation);
+  let environmentRotation = mat2x2f(
+    vec2f(rotationCosine, rotationSine),
+    vec2f(-rotationSine, rotationCosine)
+  );
+  let rotatedNormal = environmentRotation * -pbrInfo.n.xz;
+  let oppositeNormal = vec3f(rotatedNormal.x, -pbrInfo.n.y, rotatedNormal.y);
+  let environmentColor = textureSampleLevel(
+    pbr_diffuseEnvSampler,
+    pbr_diffuseEnvSamplerSampler,
+    oppositeNormal,
+    0.0
+  ).rgb * max(pbrScene.environmentIntensity, 0.0);
+#else
+  let environmentColor = SRGBtoLINEAR(
+    textureSampleLevel(pbr_diffuseEnvSampler, pbr_diffuseEnvSamplerSampler, -pbrInfo.n, 0.0)
+  ).rgb;
+#endif
+  let nonReflectedEnergy = vec3f(1.0) - clamp(pbrInfo.reflectance0, vec3f(0.0), vec3f(1.0));
+  return environmentColor * diffuseTransmissionColor * nonReflectedEnergy *
+    getDiffuseTransmissionAttenuation(pbrInfo, multiscatterColor, thickness) *
+    diffuseTransmission * pbrMaterial.scaleIBLAmbient.x;
+}
+#endif
+
+#ifdef USE_TRANSMISSION_FRAMEBUFFER
+fn sampleTransmittedSceneColor(
+  position: vec3f,
+  normal: vec3f,
+  viewDirection: vec3f,
+  thickness: f32,
+  perceptualRoughness: f32,
+  indexOfRefraction: f32
+) -> vec3f {
+  let refractionDirection = refract(
+    -viewDirection,
+    normal,
+    1.0 / max(indexOfRefraction, 1.0)
+  );
+  let refractedPosition = position + refractionDirection * thickness;
+  let clipPosition = pbrScene.projectionMatrix *
+    pbrScene.viewMatrix * vec4f(refractedPosition, 1.0);
+  var textureCoordinate = clipPosition.xy / max(clipPosition.w, 0.0001) * 0.5 + 0.5;
+  textureCoordinate.y = 1.0 - textureCoordinate.y;
+  textureCoordinate = clamp(textureCoordinate, vec2f(0.001), vec2f(0.999));
+
+  let blurRadius = perceptualRoughness * perceptualRoughness * 8.0 /
+    max(pbrScene.framebufferSize, vec2f(1.0));
+  var sceneColor = textureSampleLevel(
+    pbr_transmissionFramebufferSampler,
+    pbr_transmissionFramebufferSamplerSampler,
+    textureCoordinate,
+    0.0
+  ).rgb * 0.4;
+  sceneColor += textureSampleLevel(
+    pbr_transmissionFramebufferSampler,
+    pbr_transmissionFramebufferSamplerSampler,
+    textureCoordinate + vec2f(blurRadius.x, 0.0),
+    0.0
+  ).rgb * 0.15;
+  sceneColor += textureSampleLevel(
+    pbr_transmissionFramebufferSampler,
+    pbr_transmissionFramebufferSamplerSampler,
+    textureCoordinate - vec2f(blurRadius.x, 0.0),
+    0.0
+  ).rgb * 0.15;
+  sceneColor += textureSampleLevel(
+    pbr_transmissionFramebufferSampler,
+    pbr_transmissionFramebufferSamplerSampler,
+    textureCoordinate + vec2f(0.0, blurRadius.y),
+    0.0
+  ).rgb * 0.15;
+  sceneColor += textureSampleLevel(
+    pbr_transmissionFramebufferSampler,
+    pbr_transmissionFramebufferSamplerSampler,
+    textureCoordinate - vec2f(0.0, blurRadius.y),
+    0.0
+  ).rgb * 0.15;
+  return max(sceneColor, vec3f(0.0));
+}
+
+fn getTransmittedSceneColor(
+  position: vec3f,
+  normal: vec3f,
+  viewDirection: vec3f,
+  thickness: f32,
+  perceptualRoughness: f32
+) -> vec3f {
+  if (pbrMaterial.dispersion <= 0.0) {
+    return sampleTransmittedSceneColor(
+      position,
+      normal,
+      viewDirection,
+      thickness,
+      perceptualRoughness,
+      pbrMaterial.ior
+    );
+  }
+
+  let halfSpread = (max(pbrMaterial.ior, 1.0) - 1.0) * 0.025 * pbrMaterial.dispersion;
+  let indicesOfRefraction = max(
+    vec3f(pbrMaterial.ior - halfSpread, pbrMaterial.ior, pbrMaterial.ior + halfSpread),
+    vec3f(1.0)
+  );
+  return vec3f(
+    sampleTransmittedSceneColor(
+      position, normal, viewDirection, thickness, perceptualRoughness, indicesOfRefraction.r
+    ).r,
+    sampleTransmittedSceneColor(
+      position, normal, viewDirection, thickness, perceptualRoughness, indicesOfRefraction.g
+    ).g,
+    sampleTransmittedSceneColor(
+      position, normal, viewDirection, thickness, perceptualRoughness, indicesOfRefraction.b
+    ).b
+  );
+}
+#endif
+
+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,
+    basePBRInfo.l,
+    basePBRInfo.h
+  );
+}
+
+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 alpha = max(sheenRoughness * sheenRoughness, 0.0001);
+  let inverseAlpha = 1.0 / alpha;
+  let sineSquared = max(1.0 - pbrInfo.NdotH * pbrInfo.NdotH, 0.0);
+  let distribution = (2.0 + inverseAlpha) * pow(sineSquared, inverseAlpha * 0.5) /
+    (2.0 * M_PI);
+  let visibility = 1.0 / max(
+    4.0 * (pbrInfo.NdotL + pbrInfo.NdotV - pbrInfo.NdotL * pbrInfo.NdotV),
+    0.0001
+  );
+  return pbrInfo.NdotL * lightColor * sheenColor * distribution * visibility *
+    (1.0 - pbrInfo.metalness);
+}
+
+fn calculateAnisotropicLightColor(
+  pbrInfo: PBRInfo,
+  lightColor: vec3f,
+  anisotropyTangent: vec3f,
+  anisotropyStrength: f32
+) -> vec3f {
+  if (anisotropyStrength <= 0.0) {
+    return calculateFinalColor(pbrInfo, lightColor);
+  }
+
+  let anisotropyBitangent = normalize(cross(pbrInfo.n, anisotropyTangent));
+  let tangentRoughness = mix(
+    pbrInfo.alphaRoughness,
+    1.0,
+    anisotropyStrength * anisotropyStrength
+  );
+  let bitangentRoughness = clamp(pbrInfo.alphaRoughness, 0.001, 1.0);
+  let roughnessProduct = tangentRoughness * bitangentRoughness;
+  let distributionVector = vec3f(
+    bitangentRoughness * dot(anisotropyTangent, pbrInfo.h),
+    tangentRoughness * dot(anisotropyBitangent, pbrInfo.h),
+    roughnessProduct * pbrInfo.NdotH
+  );
+  let distributionFactor = roughnessProduct /
+    max(dot(distributionVector, distributionVector), 0.000001);
+  let distribution = roughnessProduct * distributionFactor * distributionFactor / M_PI;
+  let viewMask = pbrInfo.NdotL * length(vec3f(
+    tangentRoughness * dot(anisotropyTangent, pbrInfo.v),
+    bitangentRoughness * dot(anisotropyBitangent, pbrInfo.v),
+    pbrInfo.NdotV
+  ));
+  let lightMask = pbrInfo.NdotV * length(vec3f(
+    tangentRoughness * dot(anisotropyTangent, pbrInfo.l),
+    bitangentRoughness * dot(anisotropyBitangent, pbrInfo.l),
+    pbrInfo.NdotL
+  ));
+  let visibility = clamp(0.5 / max(viewMask + lightMask, 0.000001), 0.0, 1.0);
+  let fresnel = specularReflection(pbrInfo);
+  let diffuseContribution = (vec3f(1.0) - fresnel) * diffuse(pbrInfo);
+  return pbrInfo.NdotL * lightColor *
+    (diffuseContribution + fresnel * distribution * visibility);
+}
+
+fn getAnisotropicReflection(
+  pbrInfo: PBRInfo,
+  anisotropyTangent: vec3f,
+  anisotropyStrength: f32
+) -> vec3f {
+  if (anisotropyStrength <= 0.0) {
+    return -normalize(reflect(pbrInfo.v, pbrInfo.n));
+  }
+  let anisotropyBitangent = normalize(cross(pbrInfo.n, anisotropyTangent));
+  var anisotropicNormal = normalize(cross(anisotropyBitangent, pbrInfo.v));
+  anisotropicNormal = normalize(cross(anisotropicNormal, anisotropyBitangent));
+  let bend = anisotropyStrength * (1.0 - pbrInfo.perceptualRoughness);
+  return -normalize(reflect(pbrInfo.v, normalize(mix(pbrInfo.n, anisotropicNormal, bend))));
+}
+
+fn calculateMaterialLightColor(
+  pbrInfo: PBRInfo,
+  lightColor: vec3f,
+  clearcoatNormal: vec3f,
+  clearcoatFactor: f32,
+  clearcoatRoughness: f32,
+  sheenColor: vec3f,
+  sheenRoughness: f32,
+  anisotropyTangent: vec3f,
+  anisotropyStrength: f32
+) -> vec3f {
+  var color = calculateAnisotropicLightColor(
+    pbrInfo,
+    lightColor,
+    anisotropyTangent,
+    anisotropyStrength
+  );
+  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;
+  (*pbrInfo).LdotH = 0.0;
+  (*pbrInfo).VdotH = 1.0;
+  (*pbrInfo).l = (*pbrInfo).n;
+  (*pbrInfo).h = (*pbrInfo).n;
+}
+
+fn PBRInfo_setDirectionalLight(pbrInfo: ptr<function, PBRInfo>, lightDirection: vec3<f32>) {
+  let n = (*pbrInfo).n;
+  let v = (*pbrInfo).v;
+  let l = normalize(lightDirection);             // Vector from surface point to light
+  let h = normalize(l + v);                      // Half vector between both l and v
+
+  (*pbrInfo).NdotL = clamp(dot(n, l), 0.001, 1.0);
+  (*pbrInfo).NdotH = clamp(dot(n, h), 0.0, 1.0);
+  (*pbrInfo).LdotH = clamp(dot(l, h), 0.0, 1.0);
+  (*pbrInfo).VdotH = clamp(dot(v, h), 0.0, 1.0);
+  (*pbrInfo).l = l;
+  (*pbrInfo).h = h;
+}
+
+fn PBRInfo_setPointLight(pbrInfo: ptr<function, PBRInfo>, pointLight: PointLight) {
+  let light_direction = normalize(pointLight.position - fragmentInputs.pbr_vPosition);
+  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);
+  let G = geometricOcclusion(pbrInfo);
+  let D = microfacetDistribution(pbrInfo);
+
+  // Calculation of analytical lighting contribution
+  let diffuseContrib = (1.0 - F) * diffuse(pbrInfo);
+  let specContrib = F * G * D / (4.0 * pbrInfo.NdotL * pbrInfo.NdotV);
+  // Obtain final intensity as reflectance (BRDF) scaled by the energy of the light (cosine law)
+  return pbrInfo.NdotL * lightColor * (diffuseContrib + specContrib);
+}
+
+// Visibility for the first four spotlights; environment and other lights are unaffected.
+fn pbr_filterColorWithSpotShadows(vertexColor: vec4<f32>, spotVisibility: vec4f) -> vec4<f32> {
+  let baseColorUV = getMaterialUV(pbrMaterial.baseColorUVSet, pbrMaterial.baseColorUVTransform);
+  let metallicRoughnessUV = getMaterialUV(
+    pbrMaterial.metallicRoughnessUVSet,
+    pbrMaterial.metallicRoughnessUVTransform
+  );
+  let normalUV = getMaterialUV(pbrMaterial.normalUVSet, pbrMaterial.normalUVTransform);
+  let occlusionUV = getMaterialUV(pbrMaterial.occlusionUVSet, pbrMaterial.occlusionUVTransform);
+  let emissiveUV = getMaterialUV(pbrMaterial.emissiveUVSet, pbrMaterial.emissiveUVTransform);
+  let lightmapUV = getMaterialUV(pbrMaterial.lightmapUVSet, pbrMaterial.lightmapUVTransform);
+  let specularColorUV = getMaterialUV(
+    pbrMaterial.specularColorUVSet,
+    pbrMaterial.specularColorUVTransform
+  );
+  let specularIntensityUV = getMaterialUV(
+    pbrMaterial.specularIntensityUVSet,
+    pbrMaterial.specularIntensityUVTransform
+  );
+  let transmissionUV = getMaterialUV(
+    pbrMaterial.transmissionUVSet,
+    pbrMaterial.transmissionUVTransform
+  );
+  let thicknessUV = getMaterialUV(pbrMaterial.thicknessUVSet, pbrMaterial.thicknessUVTransform);
+  let clearcoatUV = getMaterialUV(pbrMaterial.clearcoatUVSet, pbrMaterial.clearcoatUVTransform);
+  let clearcoatRoughnessUV = getMaterialUV(
+    pbrMaterial.clearcoatRoughnessUVSet,
+    pbrMaterial.clearcoatRoughnessUVTransform
+  );
+  let clearcoatNormalUV = getMaterialUV(
+    pbrMaterial.clearcoatNormalUVSet,
+    pbrMaterial.clearcoatNormalUVTransform
+  );
+  let sheenColorUV = getMaterialUV(
+    pbrMaterial.sheenColorUVSet,
+    pbrMaterial.sheenColorUVTransform
+  );
+  let sheenRoughnessUV = getMaterialUV(
+    pbrMaterial.sheenRoughnessUVSet,
+    pbrMaterial.sheenRoughnessUVTransform
+  );
+  let iridescenceUV = getMaterialUV(
+    pbrMaterial.iridescenceUVSet,
+    pbrMaterial.iridescenceUVTransform
+  );
+  let iridescenceThicknessUV = getMaterialUV(
+    pbrMaterial.iridescenceThicknessUVSet,
+    pbrMaterial.iridescenceThicknessUVTransform
+  );
+  let anisotropyUV = getMaterialUV(
+    pbrMaterial.anisotropyUVSet,
+    pbrMaterial.anisotropyUVTransform
+  );
+  let diffuseTransmissionUV = getMaterialUV(
+    pbrMaterial.diffuseTransmissionUVSet,
+    pbrMaterial.diffuseTransmissionUVTransform
+  );
+  let diffuseTransmissionColorUV = getMaterialUV(
+    pbrMaterial.diffuseTransmissionColorUVSet,
+    pbrMaterial.diffuseTransmissionColorUVTransform
+  );
+  let multiscatterColorUV = getMaterialUV(
+    pbrMaterial.multiscatterColorUVSet,
+    pbrMaterial.multiscatterColorUVTransform
+  );
+
+  // The albedo may be defined from a base texture or a flat color
+  var baseColor: vec4<f32> = pbrMaterial.baseColorFactor * vertexColor;
+  #ifdef HAS_BASECOLORMAP
+  baseColor = SRGBtoLINEAR(
+    textureSample(pbr_baseColorSampler, pbr_baseColorSamplerSampler, baseColorUV)
+  ) * pbrMaterial.baseColorFactor * vertexColor;
+  #endif
+
+  #ifdef ALPHA_CUTOFF
+  if (baseColor.a < pbrMaterial.alphaCutoff) {
+    discard;
+  }
+  #endif
+
+  var color = vec3<f32>(0.0, 0.0, 0.0);
+  var transmission = 0.0;
+
+  var lightmapIrradiance = vec3<f32>(0.0);
+  #ifdef HAS_LIGHTMAP
+  if (pbrMaterial.lightmapMapEnabled != 0u) {
+    lightmapIrradiance = textureSample(pbr_lightmapSampler, pbr_lightmapSamplerSampler, lightmapUV).rgb * pbrMaterial.lightmapIntensity;
+  }
+  #endif
+
+  if (pbrMaterial.unlit != 0u) {
+    color = baseColor.rgb;
+    #ifdef HAS_LIGHTMAP
+    if (pbrMaterial.lightmapMapEnabled != 0u) {
+      color *= lightmapIrradiance / M_PI;
+      #ifdef HAS_OCCLUSIONMAP
+      if (pbrMaterial.occlusionMapEnabled != 0) {
+        let ao = textureSample(pbr_occlusionSampler, pbr_occlusionSamplerSampler, occlusionUV).r;
+        color = mix(color, color * ao, pbrMaterial.occlusionStrength);
+      }
+      #endif
+    }
+    #endif
+  } 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
+    var perceptualRoughness = pbrMaterial.metallicRoughnessValues.y;
+    var 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
+    let mrSample = textureSample(
+      pbr_metallicRoughnessSampler,
+      pbr_metallicRoughnessSamplerSampler,
+      metallicRoughnessUV
+    );
+    perceptualRoughness = mrSample.g * perceptualRoughness;
+    metallic = mrSample.b * metallic;
+    #endif
+    perceptualRoughness = clamp(perceptualRoughness, c_MinRoughness, 1.0);
+    metallic = clamp(metallic, 0.0, 1.0);
+    let tbn = getTBN(normalUV);
+    let n = getNormal(tbn, normalUV);                          // normal at surface point
+    perceptualRoughness = widenSpecularRoughness(perceptualRoughness, n);
+    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.dispersion > 0.0001 ||
+      pbrMaterial.transmissionMapEnabled != 0 ||
+      pbrMaterial.transmissionFactor > 0.0001 ||
+      pbrMaterial.diffuseTransmissionMapEnabled != 0 ||
+      pbrMaterial.diffuseTransmissionColorMapEnabled != 0 ||
+      pbrMaterial.diffuseTransmissionFactor > 0.0001 ||
+      pbrMaterial.multiscatterColorMapEnabled != 0 ||
+      maxComponent(pbrMaterial.multiscatterColorFactor) > 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,
+        n,
+        n
+      );
+
+      #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 * select(1.0, clamp(spotVisibility[min(i, 3)], 0.0, 1.0), i < 4) / attenuation);
+        }
+      }
+      for (var areaIndex: i32 = 0; areaIndex < areaLighting_getLightCount(); areaIndex++) {
+#ifdef USE_AREA_LIGHT_LTC
+        color += areaLTC_evaluate(areaIndex, fragmentInputs.pbr_vPosition, pbrInfo.n, pbrInfo.v, pbrInfo.perceptualRoughness, pbrInfo.diffuseColor, pbrInfo.reflectance0, pbrInfo.reflectance90);
+#else
+        for (var sampleIndex: i32 = 0; sampleIndex < areaLighting.sampleCount; sampleIndex++) {
+          let sampleLight = areaLighting_getSample(areaIndex, sampleIndex, fragmentInputs.pbr_vPosition);
+          if (dot(sampleLight.color, sampleLight.color) > 0.0) {
+            PBRInfo_setPointLight(&pbrInfo, sampleLight);
+            color += calculateFinalColor(pbrInfo, sampleLight.color);
+          }
+        }
+#endif
+      }
+      #endif
+
+      #ifdef USE_IBL
+      if (pbrMaterial.IBLenabled != 0) {
+        color += getIBLContribution(pbrInfo, n, reflection);
+      }
+      #endif
+
+      // The pinned KHR_lightmap draft explicitly defines c_diff = (1 - metallic) * baseColor.
+      color += baseColor.rgb * (1.0 - metallic) * lightmapIrradiance / M_PI;
+
+      #ifdef HAS_OCCLUSIONMAP
+      if (pbrMaterial.occlusionMapEnabled != 0) {
+        let ao = textureSample(pbr_occlusionSampler, pbr_occlusionSamplerSampler, occlusionUV).r;
+        color = mix(color, color * ao, pbrMaterial.occlusionStrength);
+      }
+      #endif
+
+      var emissive = pbrMaterial.emissiveFactor;
+      #ifdef HAS_EMISSIVEMAP
+      if (pbrMaterial.emissiveMapEnabled != 0u) {
+        emissive *= SRGBtoLINEAR(
+          textureSample(pbr_emissiveSampler, pbr_emissiveSamplerSampler, emissiveUV)
+        ).rgb;
+      }
+      #endif
+      color += emissive * pbrMaterial.emissiveStrength;
+
+      #ifdef PBR_DEBUG
+      color = mix(color, baseColor.rgb, pbrMaterial.scaleDiffBaseMR.y);
+      color = mix(color, vec3<f32>(metallic), pbrMaterial.scaleDiffBaseMR.z);
+      color = mix(color, vec3<f32>(perceptualRoughness), pbrMaterial.scaleDiffBaseMR.w);
+      #endif
+
+      return vec4<f32>(applySceneColorManagement(color), baseColor.a);
+    }
+
+    var specularIntensity = pbrMaterial.specularIntensityFactor;
+    #ifdef HAS_SPECULARINTENSITYMAP
+    if (pbrMaterial.specularIntensityMapEnabled != 0) {
+      specularIntensity *= textureSample(
+        pbr_specularIntensitySampler,
+        pbr_specularIntensitySamplerSampler,
+        specularIntensityUV
+      ).a;
+    }
+    #endif
+
+    var specularFactor = pbrMaterial.specularColorFactor;
+    #ifdef HAS_SPECULARCOLORMAP
+    if (pbrMaterial.specularColorMapEnabled != 0) {
+      specularFactor *= SRGBtoLINEAR(
+        textureSample(
+          pbr_specularColorSampler,
+          pbr_specularColorSamplerSampler,
+          specularColorUV
+        )
+      ).rgb;
+    }
+    #endif
+
+    transmission = pbrMaterial.transmissionFactor;
+    #ifdef HAS_TRANSMISSIONMAP
+    if (pbrMaterial.transmissionMapEnabled != 0) {
+      transmission *= textureSample(
+        pbr_transmissionSampler,
+        pbr_transmissionSamplerSampler,
+        transmissionUV
+      ).r;
+    }
+    #endif
+    transmission = clamp(transmission * (1.0 - metallic), 0.0, 1.0);
+    var thickness = max(pbrMaterial.thicknessFactor, 0.0);
+    #ifdef HAS_THICKNESSMAP
+    thickness *= textureSample(
+      pbr_thicknessSampler,
+      pbr_thicknessSamplerSampler,
+      thicknessUV
+    ).g;
+    #endif
+
+    var diffuseTransmission = clamp(pbrMaterial.diffuseTransmissionFactor, 0.0, 1.0);
+    #ifdef HAS_DIFFUSETRANSMISSIONMAP
+    if (pbrMaterial.diffuseTransmissionMapEnabled != 0) {
+      diffuseTransmission *= textureSample(
+        pbr_diffuseTransmissionSampler,
+        pbr_diffuseTransmissionSamplerSampler,
+        diffuseTransmissionUV
+      ).a;
+    }
+    #endif
+    diffuseTransmission *= (1.0 - metallic) * (1.0 - transmission);
+    var diffuseTransmissionColor = pbrMaterial.diffuseTransmissionColorFactor;
+    #ifdef HAS_DIFFUSETRANSMISSIONCOLORMAP
+    if (pbrMaterial.diffuseTransmissionColorMapEnabled != 0) {
+      diffuseTransmissionColor *= SRGBtoLINEAR(
+        textureSample(
+          pbr_diffuseTransmissionColorSampler,
+          pbr_diffuseTransmissionColorSamplerSampler,
+          diffuseTransmissionColorUV
+        )
+      ).rgb;
+    }
+    #endif
+    var multiscatterColor = pbrMaterial.multiscatterColorFactor;
+    #ifdef HAS_MULTISCATTERCOLORMAP
+    if (pbrMaterial.multiscatterColorMapEnabled != 0) {
+      multiscatterColor *= SRGBtoLINEAR(
+        textureSample(
+          pbr_multiscatterColorSampler,
+          pbr_multiscatterColorSamplerSampler,
+          multiscatterColorUV
+        )
+      ).rgb;
+    }
+    #endif
+
+    let originalTransmission = transmission;
+    var scatterReflection = 0.0;
+#ifdef HAS_MATERIAL_SCATTER
+    if (thickness <= 0.0) {
+      var strength = clamp(pbrMaterial.scatterStrengthFactor, 0.0, 1.0);
+#ifdef HAS_DIFFUSETRANSMISSIONMAP
+      if (pbrMaterial.diffuseTransmissionMapEnabled != 0) {
+        strength *= textureSample(
+        pbr_diffuseTransmissionSampler,
+        pbr_diffuseTransmissionSamplerSampler,
+        diffuseTransmissionUV
+      ).a;
+      }
+#endif
+      let anisotropy = pbrMaterial.scatterAnisotropy;
+      scatterReflection = originalTransmission * strength * (1.0 - anisotropy) * 0.5;
+      diffuseTransmission = originalTransmission * strength * (1.0 + anisotropy) * 0.5;
+      diffuseTransmissionColor = multiscatterColor;
+      transmission *= 1.0 - strength;
+    }
+#endif
+
+    var clearcoatFactor = pbrMaterial.clearcoatFactor;
+    var clearcoatRoughness = pbrMaterial.clearcoatRoughnessFactor;
+    #ifdef HAS_CLEARCOATMAP
+    if (pbrMaterial.clearcoatMapEnabled != 0) {
+      clearcoatFactor *= textureSample(
+        pbr_clearcoatSampler,
+        pbr_clearcoatSamplerSampler,
+        clearcoatUV
+      ).r;
+    }
+    #endif
+    #ifdef HAS_CLEARCOATROUGHNESSMAP
+    if (pbrMaterial.clearcoatRoughnessMapEnabled != 0) {
+      clearcoatRoughness *= textureSample(
+        pbr_clearcoatRoughnessSampler,
+        pbr_clearcoatRoughnessSamplerSampler,
+        clearcoatRoughnessUV
+      ).g;
+    }
+    #endif
+    clearcoatFactor = clamp(clearcoatFactor, 0.0, 1.0);
+    clearcoatRoughness = clamp(clearcoatRoughness, c_MinRoughness, 1.0);
+    let clearcoatNormal = getClearcoatNormal(getTBN(clearcoatNormalUV), n, clearcoatNormalUV);
+    clearcoatRoughness = widenSpecularRoughness(clearcoatRoughness, clearcoatNormal);
+
+    var sheenColor = pbrMaterial.sheenColorFactor;
+    var sheenRoughness = pbrMaterial.sheenRoughnessFactor;
+    #ifdef HAS_SHEENCOLORMAP
+    if (pbrMaterial.sheenColorMapEnabled != 0) {
+      sheenColor *= SRGBtoLINEAR(
+        textureSample(
+          pbr_sheenColorSampler,
+          pbr_sheenColorSamplerSampler,
+          sheenColorUV
+        )
+      ).rgb;
+    }
+    #endif
+    #ifdef HAS_SHEENROUGHNESSMAP
+    if (pbrMaterial.sheenRoughnessMapEnabled != 0) {
+      sheenRoughness *= textureSample(
+        pbr_sheenRoughnessSampler,
+        pbr_sheenRoughnessSamplerSampler,
+        sheenRoughnessUV
+      ).a;
+    }
+    #endif
+    sheenRoughness = clamp(sheenRoughness, c_MinRoughness, 1.0);
+
+    var iridescence = pbrMaterial.iridescenceFactor;
+    #ifdef HAS_IRIDESCENCEMAP
+    if (pbrMaterial.iridescenceMapEnabled != 0) {
+      iridescence *= textureSample(
+        pbr_iridescenceSampler,
+        pbr_iridescenceSamplerSampler,
+        iridescenceUV
+      ).r;
+    }
+    #endif
+    iridescence = clamp(iridescence, 0.0, 1.0);
+    var iridescenceThickness = mix(
+      pbrMaterial.iridescenceThicknessRange.x,
+      pbrMaterial.iridescenceThicknessRange.y,
+      0.5
+    );
+    #ifdef HAS_IRIDESCENCETHICKNESSMAP
+    iridescenceThickness = mix(
+      pbrMaterial.iridescenceThicknessRange.x,
+      pbrMaterial.iridescenceThicknessRange.y,
+      textureSample(
+        pbr_iridescenceThicknessSampler,
+        pbr_iridescenceThicknessSamplerSampler,
+        iridescenceThicknessUV
+      ).g
+    );
+    #endif
+
+    var anisotropyStrength = clamp(pbrMaterial.anisotropyStrength, 0.0, 1.0);
+    var anisotropyDirection = normalizeDirection(pbrMaterial.anisotropyDirection);
+    #ifdef HAS_ANISOTROPYMAP
+    if (pbrMaterial.anisotropyMapEnabled != 0) {
+      let anisotropySample = textureSample(
+        pbr_anisotropySampler,
+        pbr_anisotropySamplerSampler,
+        anisotropyUV
+      ).rgb;
+      anisotropyStrength *= anisotropySample.b;
+      let mappedDirection = anisotropySample.rg * 2.0 - 1.0;
+      if (length(mappedDirection) > 0.0001) {
+        anisotropyDirection = normalize(mappedDirection);
+      }
+    }
+    #endif
+    anisotropyDirection = rotateDirection(anisotropyDirection, pbrMaterial.anisotropyRotation);
+    var anisotropyTangent =
+      normalize(tbn[0] * anisotropyDirection.x + tbn[1] * anisotropyDirection.y);
+    if (length(anisotropyTangent) < 0.0001) {
+      anisotropyTangent = normalize(tbn[0]);
+    }
+    // Roughness is authored as perceptual roughness; as is convention,
+    // convert to material roughness by squaring the perceptual roughness [2].
+    let alphaRoughness = perceptualRoughness * perceptualRoughness;
+
+    let dielectricF0 = getDielectricF0(pbrMaterial.ior);
+    var dielectricSpecularF0 = min(
+      vec3f(dielectricF0) * specularFactor * specularIntensity,
+      vec3f(1.0)
+    );
+    dielectricSpecularF0 = getIridescenceTint(
+      iridescence,
+      iridescenceThickness,
+      NdotV,
+      dielectricSpecularF0
+    );
+    var diffuseColor = baseColor.rgb * (vec3f(1.0) - dielectricSpecularF0);
+    diffuseColor *= (1.0 - metallic) * (1.0 - transmission) * (1.0 - diffuseTransmission);
+#ifdef HAS_MATERIAL_SCATTER
+    diffuseColor = (baseColor.rgb * (1.0 - metallic) * (1.0 - originalTransmission) +
+      multiscatterColor * scatterReflection) * (vec3f(1.0) - dielectricSpecularF0);
+#endif
+    var specularColor = mix(dielectricSpecularF0, baseColor.rgb, metallic);
+
+    let clearcoatViewFresnel = dielectricSchlick(
+      0.04,
+      clamp(abs(dot(clearcoatNormal, v)), 0.0, 1.0)
+    );
+    let sheenDirectionalAlbedo = maxComponent(sheenColor) *
+      (0.157 + 0.343 * (1.0 - NdotV)) * (1.0 - sheenRoughness * 0.5);
+    let baseLayerEnergy = (1.0 - clearcoatFactor * clearcoatViewFresnel) *
+      (1.0 - clamp(sheenDirectionalAlbedo, 0.0, 1.0));
+    diffuseColor *= baseLayerEnergy;
+    specularColor *= baseLayerEnergy;
+
+    // Compute reflectance.
+    let reflectance = max(max(specularColor.r, specularColor.g), specularColor.b);
+
+    // For typical incident reflectance range (between 4% to 100%) set the grazing
+    // reflectance to 100% for typical fresnel effect.
+    // For very low reflectance range on highly diffuse objects (below 4%),
+    // incrementally reduce grazing reflectance to 0%.
+    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,
+      n,
+      n
+    );
+
+    #ifdef USE_LIGHTS
+    // Apply ambient light
+    PBRInfo_setAmbientLight(&pbrInfo);
+    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 += calculateMaterialLightColor(
+          pbrInfo,
+          lighting_getDirectionalLight(i).color,
+          clearcoatNormal,
+          clearcoatFactor,
+          clearcoatRoughness,
+          sheenColor,
+          sheenRoughness,
+          anisotropyTangent,
+          anisotropyStrength
+        );
+        color += calculateDiffuseTransmissionLight(
+          pbrInfo,
+          lighting_getDirectionalLight(i).color,
+          diffuseTransmissionColor,
+          diffuseTransmission,
+          multiscatterColor,
+          thickness
+        );
+      }
+    }
+
+    // Apply point light
+    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 += calculateMaterialLightColor(
+          pbrInfo,
+          lighting_getPointLight(i).color / attenuation,
+          clearcoatNormal,
+          clearcoatFactor,
+          clearcoatRoughness,
+          sheenColor,
+          sheenRoughness,
+          anisotropyTangent,
+          anisotropyStrength
+        );
+        color += calculateDiffuseTransmissionLight(
+          pbrInfo,
+          lighting_getPointLight(i).color / attenuation,
+          diffuseTransmissionColor,
+          diffuseTransmission,
+          multiscatterColor,
+          thickness
+        );
+      }
+    }
+
+    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 * select(1.0, clamp(spotVisibility[min(i, 3)], 0.0, 1.0), i < 4) / attenuation,
+          clearcoatNormal,
+          clearcoatFactor,
+          clearcoatRoughness,
+          sheenColor,
+          sheenRoughness,
+          anisotropyTangent,
+          anisotropyStrength
+        );
+        color += calculateDiffuseTransmissionLight(
+          pbrInfo,
+          lighting_getSpotLight(i).color * select(1.0, clamp(spotVisibility[min(i, 3)], 0.0, 1.0), i < 4) / attenuation,
+          diffuseTransmissionColor,
+          diffuseTransmission,
+          multiscatterColor,
+          thickness
+        );
+      }
+    }
+      for (var areaIndex: i32 = 0; areaIndex < areaLighting_getLightCount(); areaIndex++) {
+#ifdef USE_AREA_LIGHT_LTC
+        // Unsupported fits retain numerical integration rather than silently dropping material lobes.
+        if (anisotropyStrength <= 0.0001 && dot(sheenColor, sheenColor) <= 0.000001 && diffuseTransmission <= 0.0001) {
+        color += areaLTC_evaluate(areaIndex, fragmentInputs.pbr_vPosition, pbrInfo.n, pbrInfo.v, pbrInfo.perceptualRoughness, pbrInfo.diffuseColor, pbrInfo.reflectance0, pbrInfo.reflectance90);
+        color += clearcoatFactor * areaLTC_specular(areaLighting_getLight(areaIndex), fragmentInputs.pbr_vPosition, clearcoatNormal, pbrInfo.v, clearcoatRoughness, vec3f(0.04), vec3f(1.0));
+        } else {
+        for (var sampleIndex: i32 = 0; sampleIndex < areaLighting.sampleCount; sampleIndex++) {
+          let sampleLight = areaLighting_getSample(areaIndex, sampleIndex, fragmentInputs.pbr_vPosition);
+          if (dot(sampleLight.color, sampleLight.color) > 0.0) {
+            PBRInfo_setPointLight(&pbrInfo, sampleLight);
+            color += calculateMaterialLightColor(pbrInfo, sampleLight.color, clearcoatNormal,
+              clearcoatFactor, clearcoatRoughness, sheenColor, sheenRoughness, anisotropyTangent, anisotropyStrength);
+            color += calculateDiffuseTransmissionLight(pbrInfo, sampleLight.color,
+              diffuseTransmissionColor, diffuseTransmission, multiscatterColor, thickness);
+          }
+        }
+
+        }
+#else
+        for (var sampleIndex: i32 = 0; sampleIndex < areaLighting.sampleCount; sampleIndex++) {
+          let sampleLight = areaLighting_getSample(areaIndex, sampleIndex, fragmentInputs.pbr_vPosition);
+          if (dot(sampleLight.color, sampleLight.color) > 0.0) {
+            PBRInfo_setPointLight(&pbrInfo, sampleLight);
+            color += calculateMaterialLightColor(pbrInfo, sampleLight.color, clearcoatNormal,
+              clearcoatFactor, clearcoatRoughness, sheenColor, sheenRoughness, anisotropyTangent, anisotropyStrength);
+            color += calculateDiffuseTransmissionLight(pbrInfo, sampleLight.color,
+              diffuseTransmissionColor, diffuseTransmission, multiscatterColor, thickness);
+          }
+        }
+
+#endif
+      }
+    #endif
+
+    // Calculate lighting contribution from image based lighting source (IBL)
+    #ifdef USE_IBL
+    if (pbrMaterial.IBLenabled != 0) {
+      color += getIBLContribution(
+        pbrInfo,
+        n,
+        getAnisotropicReflection(pbrInfo, anisotropyTangent, anisotropyStrength)
+      );
+      color += calculateClearcoatIBLContribution(
+        pbrInfo,
+        clearcoatNormal,
+        -normalize(reflect(v, clearcoatNormal)),
+        clearcoatFactor,
+        clearcoatRoughness
+      );
+      color += calculateDiffuseTransmissionIBL(
+        pbrInfo,
+        diffuseTransmissionColor,
+        diffuseTransmission,
+        multiscatterColor,
+        thickness
+      );
+      color += sheenColor * pbrMaterial.scaleIBLAmbient.x * (1.0 - sheenRoughness) * 0.25;
+    }
+    #endif
+
+#ifdef HAS_MATERIAL_SCATTER
+    color += (baseColor.rgb * (1.0 - metallic) * (1.0 - originalTransmission) +
+      multiscatterColor * scatterReflection) * baseLayerEnergy * lightmapIrradiance / M_PI;
+#else
+    color += baseColor.rgb * (1.0 - metallic) * (1.0 - transmission) *
+      (1.0 - diffuseTransmission) * baseLayerEnergy * lightmapIrradiance / M_PI;
+#endif
+
+    // Apply optional PBR terms for additional (optional) shading
+    #ifdef HAS_OCCLUSIONMAP
+    if (pbrMaterial.occlusionMapEnabled != 0) {
+      let ao = textureSample(pbr_occlusionSampler, pbr_occlusionSamplerSampler, occlusionUV).r;
+      color = mix(color, color * ao, pbrMaterial.occlusionStrength);
+    }
+    #endif
+
+    var emissive = pbrMaterial.emissiveFactor;
+    #ifdef HAS_EMISSIVEMAP
+    if (pbrMaterial.emissiveMapEnabled != 0u) {
+      emissive *= SRGBtoLINEAR(
+        textureSample(pbr_emissiveSampler, pbr_emissiveSamplerSampler, emissiveUV)
+      ).rgb;
+    }
+    #endif
+    color += emissive * pbrMaterial.emissiveStrength;
+
+    if (transmission > 0.0) {
+      #ifdef USE_TRANSMISSION_FRAMEBUFFER
+      let dielectricFresnel = getDielectricF0(pbrMaterial.ior);
+      let transmissionFresnel = dielectricFresnel +
+        (1.0 - dielectricFresnel) * pow(1.0 - NdotV, 5.0);
+      let transmittedColor = getTransmittedSceneColor(
+        fragmentInputs.pbr_vPosition,
+        n,
+        v,
+        thickness,
+        perceptualRoughness
+      );
+      color += transmittedColor * getVolumeAttenuation(thickness) *
+        transmission * (1.0 - transmissionFresnel);
+      #else
+      color = mix(color, color * getVolumeAttenuation(thickness), transmission);
+      #endif
+    }
+
+    // This section uses mix to override final color for reference app visualization
+    // of various parameters in the lighting equation.
+    #ifdef PBR_DEBUG
+    // TODO: Figure out how to debug multiple lights
+
+    // color = mix(color, F, pbr_scaleFGDSpec.x);
+    // color = mix(color, vec3(G), pbr_scaleFGDSpec.y);
+    // color = mix(color, vec3(D), pbr_scaleFGDSpec.z);
+    // color = mix(color, specContrib, pbr_scaleFGDSpec.w);
+
+    // color = mix(color, diffuseContrib, pbr_scaleDiffBaseMR.x);
+    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
+  }
+
+  #ifdef USE_TRANSMISSION_FRAMEBUFFER
+  let alpha = clamp(baseColor.a, 0.0, 1.0);
+  #else
+  let alpha = clamp(baseColor.a * (1.0 - transmission), 0.0, 1.0);
+  #endif
+  return vec4<f32>(applySceneColorManagement(color), alpha);
+}
+
+fn pbr_filterColor(vertexColor: vec4<f32>) -> vec4<f32> {
+  return pbr_filterColorWithSpotShadows(vertexColor, vec4f(1.0));
+}
+`;