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

package/dist/modules/lighting/pbr-material/pbr-material-glsl.cjs

@@ -0,0 +1,1767 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var pbr_material_glsl_exports = {};
+__export(pbr_material_glsl_exports, {
+  fs: () => fs,
+  vs: () => vs
+});
+module.exports = __toCommonJS(pbr_material_glsl_exports);
+const vs = (
+  /* glsl */
+  `out vec3 pbr_vPosition;
+out vec2 pbr_vUV0;
+out vec2 pbr_vUV1;
+
+#ifdef HAS_NORMALS
+# ifdef HAS_TANGENTS
+out mat3 pbr_vTBN;
+# else
+out vec3 pbr_vNormal;
+# endif
+#endif
+
+void pbr_setPositionNormalTangentUV(
+  vec4 position,
+  vec4 normal,
+  vec4 tangent,
+  vec2 uv0,
+  vec2 uv1
+)
+{
+  vec4 pos = pbrProjection.modelMatrix * position;
+  pbr_vPosition = vec3(pos.xyz) / pos.w;
+
+#ifdef HAS_NORMALS
+#ifdef HAS_TANGENTS
+  vec3 normalW = normalize(vec3(pbrProjection.normalMatrix * vec4(normal.xyz, 0.0)));
+  vec3 tangentW = normalize(vec3(pbrProjection.modelMatrix * vec4(tangent.xyz, 0.0)));
+  vec3 bitangentW = cross(normalW, tangentW) * tangent.w;
+  pbr_vTBN = mat3(tangentW, bitangentW, normalW);
+#else // HAS_TANGENTS != 1
+  pbr_vNormal = normalize(vec3(pbrProjection.modelMatrix * vec4(normal.xyz, 0.0)));
+#endif
+#endif
+
+#ifdef HAS_UV
+  pbr_vUV0 = uv0;
+#else
+  pbr_vUV0 = vec2(0.,0.);
+#endif
+
+  pbr_vUV1 = uv1;
+}
+`
+);
+const fs = (
+  /* glsl */
+  `precision highp float;
+
+layout(std140) uniform pbrMaterialUniforms {
+  // Material is unlit
+  bool unlit;
+
+  // Base color map
+  bool baseColorMapEnabled;
+  vec4 baseColorFactor;
+
+  bool normalMapEnabled;  
+  float normalScale; // #ifdef HAS_NORMALMAP
+
+  bool emissiveMapEnabled;
+  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 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
+
+  int baseColorUVSet;
+  mat3 baseColorUVTransform;
+  int metallicRoughnessUVSet;
+  mat3 metallicRoughnessUVTransform;
+  int normalUVSet;
+  mat3 normalUVTransform;
+  int occlusionUVSet;
+  mat3 occlusionUVTransform;
+  int emissiveUVSet;
+  mat3 emissiveUVTransform;
+  int specularColorUVSet;
+  mat3 specularColorUVTransform;
+  int specularIntensityUVSet;
+  mat3 specularIntensityUVTransform;
+  int transmissionUVSet;
+  mat3 transmissionUVTransform;
+  int thicknessUVSet;
+  mat3 thicknessUVTransform;
+  int clearcoatUVSet;
+  mat3 clearcoatUVTransform;
+  int clearcoatRoughnessUVSet;
+  mat3 clearcoatRoughnessUVTransform;
+  int clearcoatNormalUVSet;
+  mat3 clearcoatNormalUVTransform;
+  int sheenColorUVSet;
+  mat3 sheenColorUVTransform;
+  int sheenRoughnessUVSet;
+  mat3 sheenRoughnessUVTransform;
+  int iridescenceUVSet;
+  mat3 iridescenceUVTransform;
+  int iridescenceThicknessUVSet;
+  mat3 iridescenceThicknessUVTransform;
+  int anisotropyUVSet;
+  mat3 anisotropyUVTransform;
+
+  float bumpFactor;
+  bool bumpMapEnabled;
+  float diffuseTransmissionFactor;
+  bool diffuseTransmissionMapEnabled;
+  vec3 diffuseTransmissionColorFactor;
+  bool diffuseTransmissionColorMapEnabled;
+  vec3 multiscatterColorFactor;
+  bool multiscatterColorMapEnabled;
+  float scatterAnisotropy;
+
+  int bumpUVSet;
+  mat3 bumpUVTransform;
+  int diffuseTransmissionUVSet;
+  mat3 diffuseTransmissionUVTransform;
+  int diffuseTransmissionColorUVSet;
+  mat3 diffuseTransmissionColorUVTransform;
+  int multiscatterColorUVSet;
+  mat3 multiscatterColorUVTransform;
+  bool lightmapMapEnabled;
+  float lightmapIntensity;
+  int lightmapUVSet;
+  mat3 lightmapUVTransform;
+  float scatterStrengthFactor;
+} pbrMaterial;
+
+// Samplers
+#ifdef HAS_BASECOLORMAP
+uniform sampler2D pbr_baseColorSampler;
+#endif
+#ifdef HAS_NORMALMAP
+uniform sampler2D pbr_normalSampler;
+#endif
+#ifdef HAS_EMISSIVEMAP
+uniform sampler2D pbr_emissiveSampler;
+#endif
+#ifdef HAS_LIGHTMAP
+uniform sampler2D pbr_lightmapSampler;
+#endif
+#ifdef HAS_METALROUGHNESSMAP
+uniform sampler2D pbr_metallicRoughnessSampler;
+#endif
+#ifdef HAS_OCCLUSIONMAP
+uniform sampler2D pbr_occlusionSampler;
+#endif
+#ifdef HAS_SPECULARCOLORMAP
+uniform sampler2D pbr_specularColorSampler;
+#endif
+#ifdef HAS_SPECULARINTENSITYMAP
+uniform sampler2D pbr_specularIntensitySampler;
+#endif
+#ifdef HAS_TRANSMISSIONMAP
+uniform sampler2D pbr_transmissionSampler;
+#endif
+#ifdef HAS_THICKNESSMAP
+uniform sampler2D pbr_thicknessSampler;
+#endif
+#ifdef HAS_CLEARCOATMAP
+uniform sampler2D pbr_clearcoatSampler;
+#endif
+#ifdef HAS_CLEARCOATROUGHNESSMAP
+uniform sampler2D pbr_clearcoatRoughnessSampler;
+#endif
+#ifdef HAS_CLEARCOATNORMALMAP
+uniform sampler2D pbr_clearcoatNormalSampler;
+#endif
+#ifdef HAS_SHEENCOLORMAP
+uniform sampler2D pbr_sheenColorSampler;
+#endif
+#ifdef HAS_SHEENROUGHNESSMAP
+uniform sampler2D pbr_sheenRoughnessSampler;
+#endif
+#ifdef HAS_IRIDESCENCEMAP
+uniform sampler2D pbr_iridescenceSampler;
+#endif
+#ifdef HAS_IRIDESCENCETHICKNESSMAP
+uniform sampler2D pbr_iridescenceThicknessSampler;
+#endif
+#ifdef HAS_ANISOTROPYMAP
+uniform sampler2D pbr_anisotropySampler;
+#endif
+#ifdef HAS_BUMPMAP
+uniform sampler2D pbr_bumpSampler;
+#endif
+#ifdef HAS_DIFFUSETRANSMISSIONMAP
+uniform sampler2D pbr_diffuseTransmissionSampler;
+#endif
+#ifdef HAS_DIFFUSETRANSMISSIONCOLORMAP
+uniform sampler2D pbr_diffuseTransmissionColorSampler;
+#endif
+#ifdef HAS_MULTISCATTERCOLORMAP
+uniform sampler2D pbr_multiscatterColorSampler;
+#endif
+// Inputs from vertex shader
+
+in vec3 pbr_vPosition;
+in vec2 pbr_vUV0;
+in vec2 pbr_vUV1;
+
+#ifdef HAS_NORMALS
+#ifdef HAS_TANGENTS
+in mat3 pbr_vTBN;
+#else
+in vec3 pbr_vNormal;
+#endif
+#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 {
+  float NdotL;                  // cos angle between normal and light direction
+  float NdotV;                  // cos angle between normal and view direction
+  float NdotH;                  // cos angle between normal and half vector
+  float LdotH;                  // cos angle between light direction and half vector
+  float VdotH;                  // cos angle between view direction and half vector
+  float perceptualRoughness;    // roughness value, as authored by the model creator (input to shader)
+  float metalness;              // metallic value at the surface
+  vec3 reflectance0;            // full reflectance color (normal incidence angle)
+  vec3 reflectance90;           // reflectance color at grazing angle
+  float alphaRoughness;         // roughness mapped to a more linear change in the roughness (proposed by [2])
+  vec3 diffuseColor;            // color contribution from diffuse lighting
+  vec3 specularColor;           // color contribution from specular lighting
+  vec3 n;                       // normal at surface point
+  vec3 v;                       // vector from surface point to camera
+  vec3 l;                       // direction from the surface toward the current light
+  vec3 h;                       // half vector between the current light and camera
+};
+
+const float M_PI = 3.141592653589793;
+const float 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.
+float widenSpecularRoughness(float perceptualRoughness, vec3 normal)
+{
+  vec3 normalDerivativeX = dFdx(normal);
+  vec3 normalDerivativeY = dFdy(normal);
+  float normalVariance =
+    dot(normalDerivativeX, normalDerivativeX) +
+    dot(normalDerivativeY, normalDerivativeY);
+  float kernelRoughnessSquared = min(2.0 * normalVariance, 1.0);
+  return clamp(
+    sqrt(perceptualRoughness * perceptualRoughness + kernelRoughnessSquared),
+    c_MinRoughness,
+    1.0
+  );
+}
+
+vec3 calculateFinalColor(PBRInfo pbrInfo, vec3 lightColor);
+
+vec4 SRGBtoLINEAR(vec4 srgbIn)
+{
+#ifdef MANUAL_SRGB
+#ifdef SRGB_FAST_APPROXIMATION
+  vec3 linOut = pow(srgbIn.xyz,vec3(2.2));
+#else // SRGB_FAST_APPROXIMATION
+  vec3 bLess = step(vec3(0.04045),srgbIn.xyz);
+  vec3 linOut = mix( srgbIn.xyz/vec3(12.92), pow((srgbIn.xyz+vec3(0.055))/vec3(1.055),vec3(2.4)), bLess );
+#endif //SRGB_FAST_APPROXIMATION
+  return vec4(linOut,srgbIn.w);;
+#else //MANUAL_SRGB
+  return srgbIn;
+#endif //MANUAL_SRGB
+}
+
+vec2 getMaterialUV(int uvSet, mat3 uvTransform)
+{
+  vec2 baseUV = uvSet == 1 ? pbr_vUV1 : pbr_vUV0;
+  return (uvTransform * vec3(baseUV, 1.0)).xy;
+}
+
+// Build the tangent basis from interpolated attributes or screen-space derivatives.
+mat3 getTBN(vec2 uv)
+{
+#ifndef HAS_TANGENTS
+  vec3 pos_dx = dFdx(pbr_vPosition);
+  vec3 pos_dy = dFdy(pbr_vPosition);
+  vec3 tex_dx = dFdx(vec3(uv, 0.0));
+  vec3 tex_dy = dFdy(vec3(uv, 0.0));
+  vec3 t = (tex_dy.t * pos_dx - tex_dx.t * pos_dy) / (tex_dx.s * tex_dy.t - tex_dy.s * tex_dx.t);
+
+#ifdef HAS_NORMALS
+  vec3 ng = normalize(pbr_vNormal);
+#else
+  vec3 ng = cross(pos_dx, pos_dy);
+#endif
+
+  t = normalize(t - ng * dot(ng, t));
+  vec3 b = normalize(cross(ng, t));
+  mat3 tbn = mat3(t, b, ng);
+#else // HAS_TANGENTS
+  mat3 tbn = pbr_vTBN;
+#endif
+
+#ifdef DOUBLE_SIDED
+#ifdef HAS_NORMALS
+  // Derivative normals already face the viewer; only flip an authored basis.
+  if (!gl_FrontFacing) tbn = mat3(-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.
+vec3 getMappedNormal(sampler2D normalSampler, mat3 tbn, float normalScale, vec2 uv)
+{
+  vec3 n = texture(normalSampler, uv).rgb;
+  return normalize(tbn * ((2.0 * n - 1.0) * vec3(normalScale, normalScale, 1.0)));
+}
+
+vec3 getNormal(mat3 tbn, vec2 uv)
+{
+#ifdef HAS_NORMALMAP
+  vec3 n = getMappedNormal(pbr_normalSampler, tbn, pbrMaterial.normalScale, uv);
+#else
+  // The tbn matrix is linearly interpolated, so we need to re-normalize
+  vec3 n = normalize(tbn[2].xyz);
+#endif
+
+#ifdef HAS_BUMPMAP
+  vec2 bumpUV = getMaterialUV(pbrMaterial.bumpUVSet, pbrMaterial.bumpUVTransform);
+  vec2 bumpTexelSize = 1.0 / vec2(textureSize(pbr_bumpSampler, 0));
+  float bumpHeight = texture(pbr_bumpSampler, bumpUV).r;
+  vec2 bumpGradient = vec2(
+    texture(pbr_bumpSampler, bumpUV + vec2(bumpTexelSize.x, 0.0)).r - bumpHeight,
+    texture(pbr_bumpSampler, bumpUV + vec2(0.0, bumpTexelSize.y)).r - bumpHeight
+  );
+  n = normalize(n - pbrMaterial.bumpFactor *
+    (tbn[0] * bumpGradient.x + tbn[1] * bumpGradient.y));
+#endif
+
+  return n;
+}
+
+vec3 getClearcoatNormal(mat3 tbn, vec3 baseNormal, vec2 uv)
+{
+#ifdef HAS_CLEARCOATNORMALMAP
+  return getMappedNormal(pbr_clearcoatNormalSampler, tbn, 1.0, uv);
+#else
+  return baseNormal;
+#endif
+}
+
+// Calculation of the lighting contribution from an optional Image Based Light source.
+// Precomputed Environment Maps are required uniform inputs and are computed as outlined in [1].
+// See our README.md on Environment Maps [3] for additional discussion.
+#ifdef USE_IBL
+vec3 getIBLContribution(PBRInfo pbrInfo, vec3 n, vec3 reflection)
+{
+#ifdef USE_SCENE_ENVIRONMENT
+  float maximumMipLevel = max(pbrScene.environmentMipCount - 1.0, 0.0);
+  float rotationSine = sin(pbrScene.environmentRotation);
+  float rotationCosine = cos(pbrScene.environmentRotation);
+  mat2 environmentRotation = mat2(rotationCosine, rotationSine, -rotationSine, rotationCosine);
+  vec3 environmentNormal = vec3(environmentRotation * n.xz, n.y).xzy;
+  vec3 environmentReflection = vec3(environmentRotation * reflection.xz, reflection.y).xzy;
+#else
+  float maximumMipLevel = 9.0;
+  vec3 environmentNormal = n;
+  vec3 environmentReflection = reflection;
+#endif
+  float lod = pbrInfo.perceptualRoughness * maximumMipLevel;
+  // retrieve a scale and bias to F0. See [1], Figure 3
+  vec4 brdfSample = texture(pbr_brdfLUT,
+    vec2(pbrInfo.NdotV, 1.0 - pbrInfo.perceptualRoughness));
+  vec4 diffuseSample = texture(pbr_diffuseEnvSampler, environmentNormal);
+
+#ifdef USE_TEX_LOD
+  vec4 specularSample = textureLod(pbr_specularEnvSampler, environmentReflection, lod);
+#else
+  vec4 specularSample = texture(pbr_specularEnvSampler, environmentReflection);
+#endif
+
+#ifdef USE_SCENE_ENVIRONMENT
+  vec3 brdf = brdfSample.rgb;
+  vec3 diffuseLight = diffuseSample.rgb;
+  vec3 specularLight = specularSample.rgb;
+#else
+  vec3 brdf = SRGBtoLINEAR(brdfSample).rgb;
+  vec3 diffuseLight = SRGBtoLINEAR(diffuseSample).rgb;
+  vec3 specularLight = SRGBtoLINEAR(specularSample).rgb;
+#endif
+
+  vec3 diffuse = diffuseLight * pbrInfo.diffuseColor;
+  vec3 specular = specularLight * (pbrInfo.specularColor * brdf.x + brdf.y);
+
+  // For presentation, this allows us to disable IBL terms
+  diffuse *= pbrMaterial.scaleIBLAmbient.x;
+  specular *= 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
+vec3 diffuse(PBRInfo pbrInfo)
+{
+  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
+vec3 specularReflection(PBRInfo pbrInfo)
+{
+  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].
+float geometricOcclusion(PBRInfo pbrInfo)
+{
+  float NdotL = pbrInfo.NdotL;
+  float NdotV = pbrInfo.NdotV;
+  float r = pbrInfo.alphaRoughness;
+
+  float attenuationL = 2.0 * NdotL / (NdotL + sqrt(r * r + (1.0 - r * r) * (NdotL * NdotL)));
+  float 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.
+float microfacetDistribution(PBRInfo pbrInfo)
+{
+  float roughnessSq = pbrInfo.alphaRoughness * pbrInfo.alphaRoughness;
+  float f = (pbrInfo.NdotH * roughnessSq - pbrInfo.NdotH) * pbrInfo.NdotH + 1.0;
+  return roughnessSq / (M_PI * f * f);
+}
+
+float maxComponent(vec3 value)
+{
+  return max(max(value.r, value.g), value.b);
+}
+
+float getDielectricF0(float ior)
+{
+  float clampedIor = max(ior, 1.0);
+  float ratio = (clampedIor - 1.0) / (clampedIor + 1.0);
+  return ratio * ratio;
+}
+
+vec2 normalizeDirection(vec2 direction)
+{
+  float directionLength = length(direction);
+  return directionLength > 0.0001 ? direction / directionLength : vec2(1.0, 0.0);
+}
+
+vec2 rotateDirection(vec2 direction, float rotation)
+{
+  float s = sin(rotation);
+  float c = cos(rotation);
+  return vec2(direction.x * c - direction.y * s, direction.x * s + direction.y * c);
+}
+
+vec3 encodeLinearSRGB(vec3 linearColor)
+{
+  vec3 positiveColor = max(linearColor, vec3(0.0));
+  return mix(
+    positiveColor * 12.92,
+    1.055 * pow(positiveColor, vec3(1.0 / 2.4)) - 0.055,
+    greaterThan(positiveColor, vec3(0.0031308))
+  );
+}
+
+vec3 toneMapKhronosPBRNeutral(vec3 color)
+{
+  const float startCompression = 0.76;
+  float darkestChannel = min(color.r, min(color.g, color.b));
+  float offset = darkestChannel < 0.08
+    ? darkestChannel - 6.25 * darkestChannel * darkestChannel
+    : 0.04;
+  color -= vec3(offset);
+
+  float peak = maxComponent(color);
+  if (peak < startCompression) {
+    return color;
+  }
+
+  float compressionRange = 1.0 - startCompression;
+  float compressedPeak = 1.0 - compressionRange * compressionRange /
+    (peak + compressionRange - startCompression);
+  color *= compressedPeak / max(peak, 0.0001);
+  float desaturation = 1.0 - 1.0 / (0.15 * (peak - compressedPeak) + 1.0);
+  return mix(color, vec3(compressedPeak), desaturation);
+}
+
+vec3 applySceneColorManagement(vec3 sceneColor)
+{
+#ifdef USE_SCENE_COLOR_MANAGEMENT
+  vec3 color = max(sceneColor, vec3(0.0)) * max(pbrScene.exposure, 0.0);
+  if (pbrScene.toneMapMode == 1) {
+    color /= vec3(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),
+      vec3(0.0),
+      vec3(1.0)
+    );
+  }
+  return pbrScene.outputEncoding == 0 ? color : encodeLinearSRGB(color);
+#else
+  return pow(max(sceneColor, vec3(0.0)), vec3(1.0 / 2.2));
+#endif
+}
+
+float dielectricSchlick(float reflectance, float cosine)
+{
+  return reflectance + (1.0 - reflectance) * pow(clamp(1.0 - cosine, 0.0, 1.0), 5.0);
+}
+
+vec3 evaluateIridescenceSensitivity(float opticalPathDifference, vec3 phaseShift)
+{
+  float phase = 2.0 * M_PI * opticalPathDifference * 1.0e-9;
+  vec3 sensitivity = vec3(5.4856e-13, 4.4201e-13, 5.2481e-13);
+  vec3 position = vec3(1.6810e6, 1.7953e6, 2.2084e6);
+  vec3 variance = vec3(4.3278e9, 9.3046e9, 6.6121e9);
+  vec3 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 mat3(
+    3.2404542, -0.9692660, 0.0556434,
+    -1.5371385, 1.8760108, -0.2040259,
+    -0.4985314, 0.0415560, 1.0572252
+  ) * xyz;
+}
+
+vec3 getIridescenceTint(float iridescence, float thickness, float NdotV, vec3 baseReflectance)
+{
+  if (iridescence <= 0.0 || thickness <= 0.0) {
+    return baseReflectance;
+  }
+
+  float filmIor = max(pbrMaterial.iridescenceIor, 1.0);
+  float sineSquared = (1.0 - NdotV * NdotV) / (filmIor * filmIor);
+  float cosineSquared = 1.0 - sineSquared;
+  if (cosineSquared <= 0.0) {
+    return mix(baseReflectance, vec3(1.0), iridescence);
+  }
+  float filmCosine = sqrt(cosineSquared);
+  float firstInterfaceReflectance = dielectricSchlick(getDielectricF0(filmIor), NdotV);
+  float transmittedEnergy = 1.0 - firstInterfaceReflectance;
+
+  vec3 baseIor = (vec3(1.0) + sqrt(clamp(baseReflectance, vec3(0.0), vec3(0.9999)))) /
+    (vec3(1.0) - sqrt(clamp(baseReflectance, vec3(0.0), vec3(0.9999))));
+  vec3 secondInterfaceF0 = (baseIor - vec3(filmIor)) / (baseIor + vec3(filmIor));
+  secondInterfaceF0 *= secondInterfaceF0;
+  vec3 secondInterfaceReflectance = secondInterfaceF0 +
+    (vec3(1.0) - secondInterfaceF0) * pow(1.0 - filmCosine, 5.0);
+  vec3 phaseShift = vec3(M_PI);
+  phaseShift += mix(vec3(0.0), vec3(M_PI), lessThan(baseIor, vec3(filmIor)));
+  float opticalPathDifference = 2.0 * filmIor * thickness * filmCosine;
+  vec3 combinedReflectance = clamp(
+    firstInterfaceReflectance * secondInterfaceReflectance,
+    vec3(0.00001),
+    vec3(0.9999)
+  );
+  vec3 recurringAmplitude = sqrt(combinedReflectance);
+  vec3 interfaceResponse = transmittedEnergy * transmittedEnergy * secondInterfaceReflectance /
+    (vec3(1.0) - combinedReflectance);
+  vec3 reflectedSpectrum = vec3(firstInterfaceReflectance) + interfaceResponse;
+  vec3 harmonicAmplitude = interfaceResponse - vec3(transmittedEnergy);
+  for (int harmonic = 1; harmonic <= 2; harmonic++) {
+    harmonicAmplitude *= recurringAmplitude;
+    reflectedSpectrum += harmonicAmplitude * 2.0 * evaluateIridescenceSensitivity(
+      float(harmonic) * opticalPathDifference,
+      float(harmonic) * phaseShift
+    );
+  }
+  return mix(baseReflectance, clamp(reflectedSpectrum, vec3(0.0), vec3(1.0)), iridescence);
+}
+
+vec3 getVolumeAttenuation(float thickness)
+{
+  if (thickness <= 0.0) {
+    return vec3(1.0);
+  }
+
+  vec3 attenuationCoefficient =
+    -log(max(pbrMaterial.attenuationColor, vec3(0.0001))) /
+    max(pbrMaterial.attenuationDistance, 0.0001);
+  return exp(-attenuationCoefficient * thickness);
+}
+
+// KHR_materials_volume_scatter is an active draft. This evaluates a local,
+// thickness-aware single-scattering approximation rather than random walk.
+vec3 getDiffuseTransmissionAttenuation(
+  PBRInfo pbrInfo,
+  vec3 multiscatterColor,
+  float thickness
+)
+{
+  vec3 volumeAttenuation = getVolumeAttenuation(thickness);
+  float scatteringStrength = maxComponent(multiscatterColor);
+  if (thickness <= 0.0 || scatteringStrength <= 0.0001) {
+    return volumeAttenuation;
+  }
+
+  float anisotropy = clamp(pbrMaterial.scatterAnisotropy, -0.95, 0.95);
+  float scatteringCosine = clamp(dot(-pbrInfo.v, pbrInfo.l), -1.0, 1.0);
+  float phaseDenominator = max(
+    1.0 + anisotropy * anisotropy - 2.0 * anisotropy * scatteringCosine,
+    0.0001
+  );
+  float phaseWeight = clamp(
+    (1.0 - anisotropy * anisotropy) / pow(phaseDenominator, 1.5),
+    0.0,
+    4.0
+  );
+  float scatteringDepth = thickness / max(pbrMaterial.attenuationDistance, 0.0001);
+  float scatteringProbability = 1.0 - exp(-scatteringDepth);
+  vec3 scatteringColor = clamp(multiscatterColor, vec3(0.0), vec3(1.0));
+  return mix(
+    volumeAttenuation,
+    volumeAttenuation * mix(vec3(1.0), scatteringColor * phaseWeight, scatteringColor),
+    scatteringProbability
+  );
+}
+
+vec3 calculateDiffuseTransmissionLight(
+  PBRInfo pbrInfo,
+  vec3 lightColor,
+  vec3 diffuseTransmissionColor,
+  float diffuseTransmission,
+  vec3 multiscatterColor,
+  float thickness
+)
+{
+  float oppositeHemisphere = max(dot(-pbrInfo.n, pbrInfo.l), 0.0);
+  if (oppositeHemisphere <= 0.0 || diffuseTransmission <= 0.0) {
+    return vec3(0.0);
+  }
+
+  vec3 nonReflectedEnergy = vec3(1.0) - clamp(pbrInfo.reflectance0, vec3(0.0), vec3(1.0));
+  vec3 attenuatedColor = getDiffuseTransmissionAttenuation(
+    pbrInfo,
+    multiscatterColor,
+    thickness
+  );
+  return lightColor * diffuseTransmissionColor * nonReflectedEnergy *
+    attenuatedColor * (diffuseTransmission * oppositeHemisphere / M_PI);
+}
+
+#ifdef USE_IBL
+vec3 calculateDiffuseTransmissionIBL(
+  PBRInfo pbrInfo,
+  vec3 diffuseTransmissionColor,
+  float diffuseTransmission,
+  vec3 multiscatterColor,
+  float thickness
+)
+{
+  if (diffuseTransmission <= 0.0) {
+    return vec3(0.0);
+  }
+
+#ifdef USE_SCENE_ENVIRONMENT
+  float rotationSine = sin(pbrScene.environmentRotation);
+  float rotationCosine = cos(pbrScene.environmentRotation);
+  mat2 environmentRotation = mat2(rotationCosine, rotationSine, -rotationSine, rotationCosine);
+  vec3 oppositeNormal = vec3(environmentRotation * -pbrInfo.n.xz, -pbrInfo.n.y).xzy;
+  vec3 environmentColor = texture(pbr_diffuseEnvSampler, oppositeNormal).rgb *
+    max(pbrScene.environmentIntensity, 0.0);
+#else
+  vec3 environmentColor = SRGBtoLINEAR(texture(pbr_diffuseEnvSampler, -pbrInfo.n)).rgb;
+#endif
+  vec3 nonReflectedEnergy = vec3(1.0) - clamp(pbrInfo.reflectance0, vec3(0.0), vec3(1.0));
+  return environmentColor * diffuseTransmissionColor * nonReflectedEnergy *
+    getDiffuseTransmissionAttenuation(pbrInfo, multiscatterColor, thickness) *
+    diffuseTransmission * pbrMaterial.scaleIBLAmbient.x;
+}
+#endif
+
+#ifdef USE_TRANSMISSION_FRAMEBUFFER
+vec3 sampleTransmittedSceneColor(
+  vec3 position,
+  vec3 normal,
+  vec3 viewDirection,
+  float thickness,
+  float perceptualRoughness,
+  float indexOfRefraction
+)
+{
+  vec3 refractionDirection = refract(
+    -viewDirection,
+    normal,
+    1.0 / max(indexOfRefraction, 1.0)
+  );
+  vec3 refractedPosition = position + refractionDirection * thickness;
+  vec4 clipPosition = pbrScene.projectionMatrix *
+    pbrScene.viewMatrix * vec4(refractedPosition, 1.0);
+  vec2 textureCoordinate = clipPosition.xy / max(clipPosition.w, 0.0001) * 0.5 + 0.5;
+  textureCoordinate = clamp(textureCoordinate, vec2(0.001), vec2(0.999));
+
+  vec2 blurRadius = perceptualRoughness * perceptualRoughness * 8.0 /
+    max(pbrScene.framebufferSize, vec2(1.0));
+  vec3 sceneColor = texture(pbr_transmissionFramebufferSampler, textureCoordinate).rgb * 0.4;
+  sceneColor += texture(
+    pbr_transmissionFramebufferSampler,
+    textureCoordinate + vec2(blurRadius.x, 0.0)
+  ).rgb * 0.15;
+  sceneColor += texture(
+    pbr_transmissionFramebufferSampler,
+    textureCoordinate - vec2(blurRadius.x, 0.0)
+  ).rgb * 0.15;
+  sceneColor += texture(
+    pbr_transmissionFramebufferSampler,
+    textureCoordinate + vec2(0.0, blurRadius.y)
+  ).rgb * 0.15;
+  sceneColor += texture(
+    pbr_transmissionFramebufferSampler,
+    textureCoordinate - vec2(0.0, blurRadius.y)
+  ).rgb * 0.15;
+  return max(sceneColor, vec3(0.0));
+}
+
+vec3 getTransmittedSceneColor(
+  vec3 position,
+  vec3 normal,
+  vec3 viewDirection,
+  float thickness,
+  float perceptualRoughness
+)
+{
+  if (pbrMaterial.dispersion <= 0.0) {
+    return sampleTransmittedSceneColor(
+      position,
+      normal,
+      viewDirection,
+      thickness,
+      perceptualRoughness,
+      pbrMaterial.ior
+    );
+  }
+
+  float halfSpread = (max(pbrMaterial.ior, 1.0) - 1.0) * 0.025 * pbrMaterial.dispersion;
+  vec3 indicesOfRefraction = max(
+    vec3(pbrMaterial.ior - halfSpread, pbrMaterial.ior, pbrMaterial.ior + halfSpread),
+    vec3(1.0)
+  );
+  return vec3(
+    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
+
+PBRInfo createClearcoatPBRInfo(PBRInfo basePBRInfo, vec3 clearcoatNormal, float clearcoatRoughness)
+{
+  float perceptualRoughness = clamp(clearcoatRoughness, c_MinRoughness, 1.0);
+  float alphaRoughness = perceptualRoughness * perceptualRoughness;
+  float NdotV = clamp(abs(dot(clearcoatNormal, basePBRInfo.v)), 0.001, 1.0);
+
+  return PBRInfo(
+    basePBRInfo.NdotL,
+    NdotV,
+    basePBRInfo.NdotH,
+    basePBRInfo.LdotH,
+    basePBRInfo.VdotH,
+    perceptualRoughness,
+    0.0,
+    vec3(0.04),
+    vec3(1.0),
+    alphaRoughness,
+    vec3(0.0),
+    vec3(0.04),
+    clearcoatNormal,
+    basePBRInfo.v,
+    basePBRInfo.l,
+    basePBRInfo.h
+  );
+}
+
+vec3 calculateClearcoatContribution(
+  PBRInfo pbrInfo,
+  vec3 lightColor,
+  vec3 clearcoatNormal,
+  float clearcoatFactor,
+  float clearcoatRoughness
+) {
+  if (clearcoatFactor <= 0.0) {
+    return vec3(0.0);
+  }
+
+  PBRInfo clearcoatPBRInfo = createClearcoatPBRInfo(pbrInfo, clearcoatNormal, clearcoatRoughness);
+  return calculateFinalColor(clearcoatPBRInfo, lightColor) * clearcoatFactor;
+}
+
+#ifdef USE_IBL
+vec3 calculateClearcoatIBLContribution(
+  PBRInfo pbrInfo,
+  vec3 clearcoatNormal,
+  vec3 reflection,
+  float clearcoatFactor,
+  float clearcoatRoughness
+) {
+  if (clearcoatFactor <= 0.0) {
+    return vec3(0.0);
+  }
+
+  PBRInfo clearcoatPBRInfo = createClearcoatPBRInfo(pbrInfo, clearcoatNormal, clearcoatRoughness);
+  return getIBLContribution(clearcoatPBRInfo, clearcoatNormal, reflection) * clearcoatFactor;
+}
+#endif
+
+vec3 calculateSheenContribution(
+  PBRInfo pbrInfo,
+  vec3 lightColor,
+  vec3 sheenColor,
+  float sheenRoughness
+) {
+  if (maxComponent(sheenColor) <= 0.0) {
+    return vec3(0.0);
+  }
+
+  float alpha = max(sheenRoughness * sheenRoughness, 0.0001);
+  float inverseAlpha = 1.0 / alpha;
+  float sineSquared = max(1.0 - pbrInfo.NdotH * pbrInfo.NdotH, 0.0);
+  float distribution = (2.0 + inverseAlpha) * pow(sineSquared, inverseAlpha * 0.5) /
+    (2.0 * M_PI);
+  float 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);
+}
+
+vec3 calculateAnisotropicLightColor(
+  PBRInfo pbrInfo,
+  vec3 lightColor,
+  vec3 anisotropyTangent,
+  float anisotropyStrength
+) {
+  if (anisotropyStrength <= 0.0) {
+    return calculateFinalColor(pbrInfo, lightColor);
+  }
+
+  vec3 anisotropyBitangent = normalize(cross(pbrInfo.n, anisotropyTangent));
+  float tangentRoughness = mix(
+    pbrInfo.alphaRoughness,
+    1.0,
+    anisotropyStrength * anisotropyStrength
+  );
+  float bitangentRoughness = clamp(pbrInfo.alphaRoughness, 0.001, 1.0);
+  float roughnessProduct = tangentRoughness * bitangentRoughness;
+  vec3 distributionVector = vec3(
+    bitangentRoughness * dot(anisotropyTangent, pbrInfo.h),
+    tangentRoughness * dot(anisotropyBitangent, pbrInfo.h),
+    roughnessProduct * pbrInfo.NdotH
+  );
+  float distributionFactor = roughnessProduct /
+    max(dot(distributionVector, distributionVector), 0.000001);
+  float distribution = roughnessProduct * distributionFactor * distributionFactor / M_PI;
+  float viewMask = pbrInfo.NdotL * length(vec3(
+    tangentRoughness * dot(anisotropyTangent, pbrInfo.v),
+    bitangentRoughness * dot(anisotropyBitangent, pbrInfo.v),
+    pbrInfo.NdotV
+  ));
+  float lightMask = pbrInfo.NdotV * length(vec3(
+    tangentRoughness * dot(anisotropyTangent, pbrInfo.l),
+    bitangentRoughness * dot(anisotropyBitangent, pbrInfo.l),
+    pbrInfo.NdotL
+  ));
+  float visibility = clamp(0.5 / max(viewMask + lightMask, 0.000001), 0.0, 1.0);
+  vec3 fresnel = specularReflection(pbrInfo);
+  vec3 diffuseContribution = (vec3(1.0) - fresnel) * diffuse(pbrInfo);
+  return pbrInfo.NdotL * lightColor *
+    (diffuseContribution + fresnel * distribution * visibility);
+}
+
+vec3 getAnisotropicReflection(PBRInfo pbrInfo, vec3 anisotropyTangent, float anisotropyStrength)
+{
+  if (anisotropyStrength <= 0.0) {
+    return -normalize(reflect(pbrInfo.v, pbrInfo.n));
+  }
+  vec3 anisotropyBitangent = normalize(cross(pbrInfo.n, anisotropyTangent));
+  vec3 anisotropicNormal = normalize(cross(anisotropyBitangent, pbrInfo.v));
+  anisotropicNormal = normalize(cross(anisotropicNormal, anisotropyBitangent));
+  float bend = anisotropyStrength * (1.0 - pbrInfo.perceptualRoughness);
+  return -normalize(reflect(pbrInfo.v, normalize(mix(pbrInfo.n, anisotropicNormal, bend))));
+}
+
+vec3 calculateMaterialLightColor(
+  PBRInfo pbrInfo,
+  vec3 lightColor,
+  vec3 clearcoatNormal,
+  float clearcoatFactor,
+  float clearcoatRoughness,
+  vec3 sheenColor,
+  float sheenRoughness,
+  vec3 anisotropyTangent,
+  float anisotropyStrength
+) {
+  vec3 color = calculateAnisotropicLightColor(
+    pbrInfo,
+    lightColor,
+    anisotropyTangent,
+    anisotropyStrength
+  );
+  color += calculateClearcoatContribution(
+    pbrInfo,
+    lightColor,
+    clearcoatNormal,
+    clearcoatFactor,
+    clearcoatRoughness
+  );
+  color += calculateSheenContribution(pbrInfo, lightColor, sheenColor, sheenRoughness);
+  return color;
+}
+
+void PBRInfo_setAmbientLight(inout PBRInfo pbrInfo) {
+  pbrInfo.NdotL = 1.0;
+  pbrInfo.NdotH = 0.0;
+  pbrInfo.LdotH = 0.0;
+  pbrInfo.VdotH = 1.0;
+  pbrInfo.l = pbrInfo.n;
+  pbrInfo.h = pbrInfo.n;
+}
+
+void PBRInfo_setDirectionalLight(inout PBRInfo pbrInfo, vec3 lightDirection) {
+  vec3 n = pbrInfo.n;
+  vec3 v = pbrInfo.v;
+  vec3 l = normalize(lightDirection);             // Vector from surface point to light
+  vec3 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;
+}
+
+void PBRInfo_setPointLight(inout PBRInfo pbrInfo, PointLight pointLight) {
+  vec3 light_direction = normalize(pointLight.position - pbr_vPosition);
+  PBRInfo_setDirectionalLight(pbrInfo, light_direction);
+}
+
+void PBRInfo_setSpotLight(inout PBRInfo pbrInfo, SpotLight spotLight) {
+  vec3 light_direction = normalize(spotLight.position - pbr_vPosition);
+  PBRInfo_setDirectionalLight(pbrInfo, light_direction);
+}
+
+vec3 calculateFinalColor(PBRInfo pbrInfo, vec3 lightColor) {
+  // Calculate the shading terms for the microfacet specular shading model
+  vec3 F = specularReflection(pbrInfo);
+  float G = geometricOcclusion(pbrInfo);
+  float D = microfacetDistribution(pbrInfo);
+
+  // Calculation of analytical lighting contribution
+  vec3 diffuseContrib = (1.0 - F) * diffuse(pbrInfo);
+  vec3 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.
+vec4 pbr_filterColorWithSpotShadows(vec4 vertexColor, vec4 spotVisibility)
+{
+  vec2 baseColorUV = getMaterialUV(pbrMaterial.baseColorUVSet, pbrMaterial.baseColorUVTransform);
+  vec2 metallicRoughnessUV = getMaterialUV(
+    pbrMaterial.metallicRoughnessUVSet,
+    pbrMaterial.metallicRoughnessUVTransform
+  );
+  vec2 normalUV = getMaterialUV(pbrMaterial.normalUVSet, pbrMaterial.normalUVTransform);
+  vec2 occlusionUV = getMaterialUV(pbrMaterial.occlusionUVSet, pbrMaterial.occlusionUVTransform);
+  vec2 emissiveUV = getMaterialUV(pbrMaterial.emissiveUVSet, pbrMaterial.emissiveUVTransform);
+  vec2 lightmapUV = getMaterialUV(pbrMaterial.lightmapUVSet, pbrMaterial.lightmapUVTransform);
+  vec2 specularColorUV = getMaterialUV(
+    pbrMaterial.specularColorUVSet,
+    pbrMaterial.specularColorUVTransform
+  );
+  vec2 specularIntensityUV = getMaterialUV(
+    pbrMaterial.specularIntensityUVSet,
+    pbrMaterial.specularIntensityUVTransform
+  );
+  vec2 transmissionUV = getMaterialUV(
+    pbrMaterial.transmissionUVSet,
+    pbrMaterial.transmissionUVTransform
+  );
+  vec2 thicknessUV = getMaterialUV(pbrMaterial.thicknessUVSet, pbrMaterial.thicknessUVTransform);
+  vec2 clearcoatUV = getMaterialUV(pbrMaterial.clearcoatUVSet, pbrMaterial.clearcoatUVTransform);
+  vec2 clearcoatRoughnessUV = getMaterialUV(
+    pbrMaterial.clearcoatRoughnessUVSet,
+    pbrMaterial.clearcoatRoughnessUVTransform
+  );
+  vec2 clearcoatNormalUV = getMaterialUV(
+    pbrMaterial.clearcoatNormalUVSet,
+    pbrMaterial.clearcoatNormalUVTransform
+  );
+  vec2 sheenColorUV = getMaterialUV(
+    pbrMaterial.sheenColorUVSet,
+    pbrMaterial.sheenColorUVTransform
+  );
+  vec2 sheenRoughnessUV = getMaterialUV(
+    pbrMaterial.sheenRoughnessUVSet,
+    pbrMaterial.sheenRoughnessUVTransform
+  );
+  vec2 iridescenceUV = getMaterialUV(
+    pbrMaterial.iridescenceUVSet,
+    pbrMaterial.iridescenceUVTransform
+  );
+  vec2 iridescenceThicknessUV = getMaterialUV(
+    pbrMaterial.iridescenceThicknessUVSet,
+    pbrMaterial.iridescenceThicknessUVTransform
+  );
+  vec2 anisotropyUV = getMaterialUV(
+    pbrMaterial.anisotropyUVSet,
+    pbrMaterial.anisotropyUVTransform
+  );
+  vec2 diffuseTransmissionUV = getMaterialUV(
+    pbrMaterial.diffuseTransmissionUVSet,
+    pbrMaterial.diffuseTransmissionUVTransform
+  );
+  vec2 diffuseTransmissionColorUV = getMaterialUV(
+    pbrMaterial.diffuseTransmissionColorUVSet,
+    pbrMaterial.diffuseTransmissionColorUVTransform
+  );
+  vec2 multiscatterColorUV = getMaterialUV(
+    pbrMaterial.multiscatterColorUVSet,
+    pbrMaterial.multiscatterColorUVTransform
+  );
+
+  // The albedo may be defined from a base texture or a flat color
+#ifdef HAS_BASECOLORMAP
+  vec4 baseColor =
+    SRGBtoLINEAR(texture(pbr_baseColorSampler, baseColorUV)) *
+    pbrMaterial.baseColorFactor * vertexColor;
+#else
+  vec4 baseColor = pbrMaterial.baseColorFactor * vertexColor;
+#endif
+
+#ifdef ALPHA_CUTOFF
+  if (baseColor.a < pbrMaterial.alphaCutoff) {
+    discard;
+  }
+#endif
+
+  vec3 color = vec3(0, 0, 0);
+
+  float transmission = 0.0;
+
+  vec3 lightmapIrradiance = vec3(0.0);
+#ifdef HAS_LIGHTMAP
+  if (pbrMaterial.lightmapMapEnabled) {
+    lightmapIrradiance = texture(pbr_lightmapSampler, lightmapUV).rgb * pbrMaterial.lightmapIntensity;
+  }
+#endif
+
+  if(pbrMaterial.unlit){
+    color.rgb = baseColor.rgb;
+#ifdef HAS_LIGHTMAP
+    if (pbrMaterial.lightmapMapEnabled) {
+      color *= lightmapIrradiance / M_PI;
+#ifdef HAS_OCCLUSIONMAP
+      if (pbrMaterial.occlusionMapEnabled) {
+        float ao = texture(pbr_occlusionSampler, 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
+    float perceptualRoughness = pbrMaterial.metallicRoughnessValues.y;
+    float metallic = pbrMaterial.metallicRoughnessValues.x;
+#ifdef HAS_METALROUGHNESSMAP
+    // Roughness is stored in the 'g' channel, metallic is stored in the 'b' channel.
+    // This layout intentionally reserves the 'r' channel for (optional) occlusion map data
+    vec4 mrSample = texture(pbr_metallicRoughnessSampler, metallicRoughnessUV);
+    perceptualRoughness = mrSample.g * perceptualRoughness;
+    metallic = mrSample.b * metallic;
+#endif
+    perceptualRoughness = clamp(perceptualRoughness, c_MinRoughness, 1.0);
+    metallic = clamp(metallic, 0.0, 1.0);
+    mat3 tbn = getTBN(normalUV);
+    vec3 n = getNormal(tbn, normalUV);                          // normal at surface point
+    perceptualRoughness = widenSpecularRoughness(perceptualRoughness, n);
+    vec3 v = normalize(pbrProjection.camera - pbr_vPosition);  // Vector from surface point to camera
+    float NdotV = clamp(abs(dot(n, v)), 0.001, 1.0);
+#ifdef USE_MATERIAL_EXTENSIONS
+    bool useExtendedPBR =
+      pbrMaterial.specularColorMapEnabled ||
+      pbrMaterial.specularIntensityMapEnabled ||
+      abs(pbrMaterial.specularIntensityFactor - 1.0) > 0.0001 ||
+      maxComponent(abs(pbrMaterial.specularColorFactor - vec3(1.0))) > 0.0001 ||
+      abs(pbrMaterial.ior - 1.5) > 0.0001 ||
+      pbrMaterial.dispersion > 0.0001 ||
+      pbrMaterial.transmissionMapEnabled ||
+      pbrMaterial.transmissionFactor > 0.0001 ||
+      pbrMaterial.diffuseTransmissionMapEnabled ||
+      pbrMaterial.diffuseTransmissionColorMapEnabled ||
+      pbrMaterial.diffuseTransmissionFactor > 0.0001 ||
+      pbrMaterial.multiscatterColorMapEnabled ||
+      maxComponent(pbrMaterial.multiscatterColorFactor) > 0.0001 ||
+      pbrMaterial.clearcoatMapEnabled ||
+      pbrMaterial.clearcoatRoughnessMapEnabled ||
+      pbrMaterial.clearcoatFactor > 0.0001 ||
+      pbrMaterial.clearcoatRoughnessFactor > 0.0001 ||
+      pbrMaterial.sheenColorMapEnabled ||
+      pbrMaterial.sheenRoughnessMapEnabled ||
+      maxComponent(pbrMaterial.sheenColorFactor) > 0.0001 ||
+      pbrMaterial.sheenRoughnessFactor > 0.0001 ||
+      pbrMaterial.iridescenceMapEnabled ||
+      pbrMaterial.iridescenceFactor > 0.0001 ||
+      abs(pbrMaterial.iridescenceIor - 1.3) > 0.0001 ||
+      abs(pbrMaterial.iridescenceThicknessRange.x - 100.0) > 0.0001 ||
+      abs(pbrMaterial.iridescenceThicknessRange.y - 400.0) > 0.0001 ||
+      pbrMaterial.anisotropyMapEnabled ||
+      pbrMaterial.anisotropyStrength > 0.0001 ||
+      abs(pbrMaterial.anisotropyRotation) > 0.0001 ||
+      length(pbrMaterial.anisotropyDirection - vec2(1.0, 0.0)) > 0.0001;
+#else
+    bool useExtendedPBR = false;
+#endif
+
+    if (!useExtendedPBR) {
+      // Keep the baseline metallic-roughness implementation byte-for-byte equivalent in behavior.
+      float alphaRoughness = perceptualRoughness * perceptualRoughness;
+
+      vec3 f0 = vec3(0.04);
+      vec3 diffuseColor = baseColor.rgb * (vec3(1.0) - f0);
+      diffuseColor *= 1.0 - metallic;
+      vec3 specularColor = mix(f0, baseColor.rgb, metallic);
+
+      float reflectance = max(max(specularColor.r, specularColor.g), specularColor.b);
+      float reflectance90 = clamp(reflectance * 25.0, 0.0, 1.0);
+      vec3 specularEnvironmentR0 = specularColor.rgb;
+      vec3 specularEnvironmentR90 = vec3(1.0, 1.0, 1.0) * reflectance90;
+      vec3 reflection = -normalize(reflect(v, n));
+
+      PBRInfo pbrInfo = PBRInfo(
+        0.0, // NdotL
+        NdotV,
+        0.0, // NdotH
+        0.0, // LdotH
+        0.0, // VdotH
+        perceptualRoughness,
+        metallic,
+        specularEnvironmentR0,
+        specularEnvironmentR90,
+        alphaRoughness,
+        diffuseColor,
+        specularColor,
+        n,
+        v,
+        n,
+        n
+      );
+
+#ifdef USE_LIGHTS
+      PBRInfo_setAmbientLight(pbrInfo);
+      color += calculateFinalColor(pbrInfo, lighting.ambientColor);
+
+      for(int i = 0; i < lighting.directionalLightCount; i++) {
+        if (i < lighting.directionalLightCount) {
+          PBRInfo_setDirectionalLight(pbrInfo, lighting_getDirectionalLight(i).direction);
+          color += calculateFinalColor(pbrInfo, lighting_getDirectionalLight(i).color);
+        }
+      }
+
+      for(int i = 0; i < lighting.pointLightCount; i++) {
+        if (i < lighting.pointLightCount) {
+          PBRInfo_setPointLight(pbrInfo, lighting_getPointLight(i));
+          float attenuation = getPointLightAttenuation(lighting_getPointLight(i), distance(lighting_getPointLight(i).position, pbr_vPosition));
+          color += calculateFinalColor(pbrInfo, lighting_getPointLight(i).color / attenuation);
+        }
+      }
+
+      for(int i = 0; i < lighting.spotLightCount; i++) {
+        if (i < lighting.spotLightCount) {
+          PBRInfo_setSpotLight(pbrInfo, lighting_getSpotLight(i));
+          float attenuation = getSpotLightAttenuation(lighting_getSpotLight(i), pbr_vPosition);
+          color += calculateFinalColor(pbrInfo, lighting_getSpotLight(i).color * (i < 4 ? clamp(spotVisibility[min(i, 3)], 0.0, 1.0) : 1.0) / attenuation);
+        }
+      }
+      for (int areaIndex = 0; areaIndex < areaLighting_getLightCount(); areaIndex++) {
+#ifdef USE_AREA_LIGHT_LTC
+        color += areaLTC_evaluate(areaIndex, pbr_vPosition, pbrInfo.n, pbrInfo.v, pbrInfo.perceptualRoughness, pbrInfo.diffuseColor, pbrInfo.reflectance0, pbrInfo.reflectance90);
+#else
+        for (int sampleIndex = 0; sampleIndex < areaLighting.sampleCount; sampleIndex++) {
+          PointLight sampleLight = areaLighting_getSample(areaIndex, sampleIndex, 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) {
+        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) {
+        float ao = texture(pbr_occlusionSampler, occlusionUV).r;
+        color = mix(color, color * ao, pbrMaterial.occlusionStrength);
+      }
+#endif
+
+      vec3 emissive = pbrMaterial.emissiveFactor;
+#ifdef HAS_EMISSIVEMAP
+      if (pbrMaterial.emissiveMapEnabled) {
+        emissive *= SRGBtoLINEAR(texture(pbr_emissiveSampler, emissiveUV)).rgb;
+      }
+#endif
+      color += emissive * pbrMaterial.emissiveStrength;
+
+#ifdef PBR_DEBUG
+      color = mix(color, baseColor.rgb, pbrMaterial.scaleDiffBaseMR.y);
+      color = mix(color, vec3(metallic), pbrMaterial.scaleDiffBaseMR.z);
+      color = mix(color, vec3(perceptualRoughness), pbrMaterial.scaleDiffBaseMR.w);
+#endif
+
+      return vec4(applySceneColorManagement(color), baseColor.a);
+    }
+
+    float specularIntensity = pbrMaterial.specularIntensityFactor;
+#ifdef HAS_SPECULARINTENSITYMAP
+    if (pbrMaterial.specularIntensityMapEnabled) {
+      specularIntensity *= texture(pbr_specularIntensitySampler, specularIntensityUV).a;
+    }
+#endif
+
+    vec3 specularFactor = pbrMaterial.specularColorFactor;
+#ifdef HAS_SPECULARCOLORMAP
+    if (pbrMaterial.specularColorMapEnabled) {
+      specularFactor *= SRGBtoLINEAR(texture(pbr_specularColorSampler, specularColorUV)).rgb;
+    }
+#endif
+
+    transmission = pbrMaterial.transmissionFactor;
+#ifdef HAS_TRANSMISSIONMAP
+    if (pbrMaterial.transmissionMapEnabled) {
+      transmission *= texture(pbr_transmissionSampler, transmissionUV).r;
+    }
+#endif
+    transmission = clamp(transmission * (1.0 - metallic), 0.0, 1.0);
+    float thickness = max(pbrMaterial.thicknessFactor, 0.0);
+#ifdef HAS_THICKNESSMAP
+    thickness *= texture(pbr_thicknessSampler, thicknessUV).g;
+#endif
+
+    float diffuseTransmission = clamp(pbrMaterial.diffuseTransmissionFactor, 0.0, 1.0);
+#ifdef HAS_DIFFUSETRANSMISSIONMAP
+    if (pbrMaterial.diffuseTransmissionMapEnabled) {
+      diffuseTransmission *= texture(pbr_diffuseTransmissionSampler, diffuseTransmissionUV).a;
+    }
+#endif
+    diffuseTransmission *= (1.0 - metallic) * (1.0 - transmission);
+    vec3 diffuseTransmissionColor = pbrMaterial.diffuseTransmissionColorFactor;
+#ifdef HAS_DIFFUSETRANSMISSIONCOLORMAP
+    if (pbrMaterial.diffuseTransmissionColorMapEnabled) {
+      diffuseTransmissionColor *= SRGBtoLINEAR(
+        texture(pbr_diffuseTransmissionColorSampler, diffuseTransmissionColorUV)
+      ).rgb;
+    }
+#endif
+    vec3 multiscatterColor = pbrMaterial.multiscatterColorFactor;
+#ifdef HAS_MULTISCATTERCOLORMAP
+    if (pbrMaterial.multiscatterColorMapEnabled) {
+      multiscatterColor *= SRGBtoLINEAR(
+        texture(pbr_multiscatterColorSampler, multiscatterColorUV)
+      ).rgb;
+    }
+#endif
+
+    float originalTransmission = transmission;
+    float scatterReflection = 0.0;
+#ifdef HAS_MATERIAL_SCATTER
+    if (thickness <= 0.0) {
+      float strength = clamp(pbrMaterial.scatterStrengthFactor, 0.0, 1.0);
+#ifdef HAS_DIFFUSETRANSMISSIONMAP
+      if (pbrMaterial.diffuseTransmissionMapEnabled) {
+        strength *= texture(pbr_diffuseTransmissionSampler, diffuseTransmissionUV).a;
+      }
+#endif
+      float 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
+
+    float clearcoatFactor = pbrMaterial.clearcoatFactor;
+    float clearcoatRoughness = pbrMaterial.clearcoatRoughnessFactor;
+#ifdef HAS_CLEARCOATMAP
+    if (pbrMaterial.clearcoatMapEnabled) {
+      clearcoatFactor *= texture(pbr_clearcoatSampler, clearcoatUV).r;
+    }
+#endif
+#ifdef HAS_CLEARCOATROUGHNESSMAP
+    if (pbrMaterial.clearcoatRoughnessMapEnabled) {
+      clearcoatRoughness *= texture(pbr_clearcoatRoughnessSampler, clearcoatRoughnessUV).g;
+    }
+#endif
+    clearcoatFactor = clamp(clearcoatFactor, 0.0, 1.0);
+    clearcoatRoughness = clamp(clearcoatRoughness, c_MinRoughness, 1.0);
+    vec3 clearcoatNormal = getClearcoatNormal(getTBN(clearcoatNormalUV), n, clearcoatNormalUV);
+    clearcoatRoughness = widenSpecularRoughness(clearcoatRoughness, clearcoatNormal);
+
+    vec3 sheenColor = pbrMaterial.sheenColorFactor;
+    float sheenRoughness = pbrMaterial.sheenRoughnessFactor;
+#ifdef HAS_SHEENCOLORMAP
+    if (pbrMaterial.sheenColorMapEnabled) {
+      sheenColor *= SRGBtoLINEAR(texture(pbr_sheenColorSampler, sheenColorUV)).rgb;
+    }
+#endif
+#ifdef HAS_SHEENROUGHNESSMAP
+    if (pbrMaterial.sheenRoughnessMapEnabled) {
+      sheenRoughness *= texture(pbr_sheenRoughnessSampler, sheenRoughnessUV).a;
+    }
+#endif
+    sheenRoughness = clamp(sheenRoughness, c_MinRoughness, 1.0);
+
+    float iridescence = pbrMaterial.iridescenceFactor;
+#ifdef HAS_IRIDESCENCEMAP
+    if (pbrMaterial.iridescenceMapEnabled) {
+      iridescence *= texture(pbr_iridescenceSampler, iridescenceUV).r;
+    }
+#endif
+    iridescence = clamp(iridescence, 0.0, 1.0);
+    float iridescenceThickness = mix(
+      pbrMaterial.iridescenceThicknessRange.x,
+      pbrMaterial.iridescenceThicknessRange.y,
+      0.5
+    );
+#ifdef HAS_IRIDESCENCETHICKNESSMAP
+    iridescenceThickness = mix(
+      pbrMaterial.iridescenceThicknessRange.x,
+      pbrMaterial.iridescenceThicknessRange.y,
+      texture(pbr_iridescenceThicknessSampler, iridescenceThicknessUV).g
+    );
+#endif
+
+    float anisotropyStrength = clamp(pbrMaterial.anisotropyStrength, 0.0, 1.0);
+    vec2 anisotropyDirection = normalizeDirection(pbrMaterial.anisotropyDirection);
+#ifdef HAS_ANISOTROPYMAP
+    if (pbrMaterial.anisotropyMapEnabled) {
+      vec3 anisotropySample = texture(pbr_anisotropySampler, anisotropyUV).rgb;
+      anisotropyStrength *= anisotropySample.b;
+      vec2 mappedDirection = anisotropySample.rg * 2.0 - 1.0;
+      if (length(mappedDirection) > 0.0001) {
+        anisotropyDirection = normalize(mappedDirection);
+      }
+    }
+#endif
+    anisotropyDirection = rotateDirection(anisotropyDirection, pbrMaterial.anisotropyRotation);
+    vec3 anisotropyTangent = normalize(tbn[0] * anisotropyDirection.x + tbn[1] * anisotropyDirection.y);
+    if (length(anisotropyTangent) < 0.0001) {
+      anisotropyTangent = normalize(tbn[0]);
+    }
+    // Roughness is authored as perceptual roughness; as is convention,
+    // convert to material roughness by squaring the perceptual roughness [2].
+    float alphaRoughness = perceptualRoughness * perceptualRoughness;
+
+    float dielectricF0 = getDielectricF0(pbrMaterial.ior);
+    vec3 dielectricSpecularF0 = min(
+      vec3(dielectricF0) * specularFactor * specularIntensity,
+      vec3(1.0)
+    );
+    dielectricSpecularF0 = getIridescenceTint(
+      iridescence,
+      iridescenceThickness,
+      NdotV,
+      dielectricSpecularF0
+    );
+    vec3 diffuseColor = baseColor.rgb * (vec3(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) * (vec3(1.0) - dielectricSpecularF0);
+#endif
+    vec3 specularColor = mix(dielectricSpecularF0, baseColor.rgb, metallic);
+
+    float clearcoatViewFresnel = dielectricSchlick(
+      0.04,
+      clamp(abs(dot(clearcoatNormal, v)), 0.0, 1.0)
+    );
+    float sheenDirectionalAlbedo = maxComponent(sheenColor) *
+      (0.157 + 0.343 * (1.0 - NdotV)) * (1.0 - sheenRoughness * 0.5);
+    float baseLayerEnergy = (1.0 - clearcoatFactor * clearcoatViewFresnel) *
+      (1.0 - clamp(sheenDirectionalAlbedo, 0.0, 1.0));
+    diffuseColor *= baseLayerEnergy;
+    specularColor *= baseLayerEnergy;
+
+    // Compute reflectance.
+    float 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 reflecance to 0%.
+    float reflectance90 = clamp(reflectance * 25.0, 0.0, 1.0);
+    vec3 specularEnvironmentR0 = specularColor.rgb;
+    vec3 specularEnvironmentR90 = vec3(1.0, 1.0, 1.0) * reflectance90;
+    vec3 reflection = -normalize(reflect(v, n));
+
+    PBRInfo pbrInfo = PBRInfo(
+      0.0, // NdotL
+      NdotV,
+      0.0, // NdotH
+      0.0, // LdotH
+      0.0, // VdotH
+      perceptualRoughness,
+      metallic,
+      specularEnvironmentR0,
+      specularEnvironmentR90,
+      alphaRoughness,
+      diffuseColor,
+      specularColor,
+      n,
+      v,
+      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(int 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(int i = 0; i < lighting.pointLightCount; i++) {
+      if (i < lighting.pointLightCount) {
+        PBRInfo_setPointLight(pbrInfo, lighting_getPointLight(i));
+        float attenuation = getPointLightAttenuation(lighting_getPointLight(i), distance(lighting_getPointLight(i).position, pbr_vPosition));
+        color += 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(int i = 0; i < lighting.spotLightCount; i++) {
+      if (i < lighting.spotLightCount) {
+        PBRInfo_setSpotLight(pbrInfo, lighting_getSpotLight(i));
+        float attenuation = getSpotLightAttenuation(lighting_getSpotLight(i), pbr_vPosition);
+        color += calculateMaterialLightColor(
+          pbrInfo,
+          lighting_getSpotLight(i).color * (i < 4 ? clamp(spotVisibility[min(i, 3)], 0.0, 1.0) : 1.0) / attenuation,
+          clearcoatNormal,
+          clearcoatFactor,
+          clearcoatRoughness,
+          sheenColor,
+          sheenRoughness,
+          anisotropyTangent,
+          anisotropyStrength
+        );
+        color += calculateDiffuseTransmissionLight(
+          pbrInfo,
+          lighting_getSpotLight(i).color * (i < 4 ? clamp(spotVisibility[min(i, 3)], 0.0, 1.0) : 1.0) / attenuation,
+          diffuseTransmissionColor,
+          diffuseTransmission,
+          multiscatterColor,
+          thickness
+        );
+      }
+    }
+      for (int areaIndex = 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, pbr_vPosition, pbrInfo.n, pbrInfo.v, pbrInfo.perceptualRoughness, pbrInfo.diffuseColor, pbrInfo.reflectance0, pbrInfo.reflectance90);
+        color += clearcoatFactor * areaLTC_specular(areaLighting_getLight(areaIndex), pbr_vPosition, clearcoatNormal, pbrInfo.v, clearcoatRoughness, vec3(0.04), vec3(1.0));
+        } else {
+        for (int sampleIndex = 0; sampleIndex < areaLighting.sampleCount; sampleIndex++) {
+          PointLight sampleLight = areaLighting_getSample(areaIndex, sampleIndex, 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 (int sampleIndex = 0; sampleIndex < areaLighting.sampleCount; sampleIndex++) {
+          PointLight sampleLight = areaLighting_getSample(areaIndex, sampleIndex, 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) {
+      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) {
+      float ao = texture(pbr_occlusionSampler, occlusionUV).r;
+      color = mix(color, color * ao, pbrMaterial.occlusionStrength);
+    }
+#endif
+
+    vec3 emissive = pbrMaterial.emissiveFactor;
+#ifdef HAS_EMISSIVEMAP
+    if (pbrMaterial.emissiveMapEnabled) {
+      emissive *= SRGBtoLINEAR(texture(pbr_emissiveSampler, emissiveUV)).rgb;
+    }
+#endif
+    color += emissive * pbrMaterial.emissiveStrength;
+
+    if (transmission > 0.0) {
+#ifdef USE_TRANSMISSION_FRAMEBUFFER
+      float dielectricFresnel = getDielectricF0(pbrMaterial.ior);
+      float transmissionFresnel = dielectricFresnel +
+        (1.0 - dielectricFresnel) * pow(1.0 - NdotV, 5.0);
+      vec3 transmittedColor = getTransmittedSceneColor(
+        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(metallic), pbrMaterial.scaleDiffBaseMR.z);
+    color = mix(color, vec3(perceptualRoughness), pbrMaterial.scaleDiffBaseMR.w);
+#endif
+
+  }
+
+#ifdef USE_TRANSMISSION_FRAMEBUFFER
+  float alpha = clamp(baseColor.a, 0.0, 1.0);
+#else
+  float alpha = clamp(baseColor.a * (1.0 - transmission), 0.0, 1.0);
+#endif
+  return vec4(applySceneColorManagement(color), alpha);
+}
+
+vec4 pbr_filterColor(vec4 vertexColor) {
+  return pbr_filterColorWithSpotShadows(vertexColor, vec4(1.0));
+}
+`
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  fs,
+  vs
+});