@cesium/engine 9.1.0 → 9.2.0

package/Source/Shaders/Model/ImageBasedLightingStageFS.js

@@ -1,166 +1,245 @@
 //This file is automatically rebuilt by the Cesium build process.
-export default "vec3 proceduralIBL(\n\
-    vec3 positionEC,\n\
-    vec3 normalEC,\n\
-    vec3 lightDirectionEC,\n\
-    vec3 lightColorHdr,\n\
-    czm_pbrParameters pbrParameters\n\
-) {\n\
-    vec3 v = -positionEC;\n\
-    vec3 positionWC = vec3(czm_inverseView * vec4(positionEC, 1.0));\n\
-    vec3 vWC = -normalize(positionWC);\n\
-    vec3 l = normalize(lightDirectionEC);\n\
-    vec3 n = normalEC;\n\
-    vec3 r = normalize(czm_inverseViewRotation * normalize(reflect(v, n)));\n\
+export default "/**\n\
+ * Compute some metrics for a procedural sky lighting model\n\
+ *\n\
+ * @param {vec3} positionWC The position of the fragment in world coordinates.\n\
+ * @param {vec3} reflectionWC A unit vector in the direction of the reflection, in world coordinates.\n\
+ * @return {vec3} The dot products of the horizon and reflection directions with the nadir, and an atmosphere boundary distance.\n\
+ */\n\
+vec3 getProceduralSkyMetrics(vec3 positionWC, vec3 reflectionWC)\n\
+{\n\
+    // Figure out if the reflection vector hits the ellipsoid\n\
+    float horizonDotNadir = 1.0 - min(1.0, czm_ellipsoidRadii.x / length(positionWC));\n\
+    float reflectionDotNadir = dot(reflectionWC, normalize(positionWC));\n\
+    float atmosphereHeight = 0.05;\n\
+    float smoothstepHeight = smoothstep(0.0, atmosphereHeight, horizonDotNadir);\n\
+    return vec3(horizonDotNadir, reflectionDotNadir, smoothstepHeight);\n\
+}\n\
 \n\
-    float NdotL = clamp(dot(n, l), 0.001, 1.0);\n\
-    float NdotV = abs(dot(n, v)) + 0.001;\n\
+/**\n\
+ * Compute the diffuse irradiance for a procedural sky lighting model\n\
+ *\n\
+ * @param {vec3} skyMetrics The dot products of the horizon and reflection directions with the nadir, and an atmosphere boundary distance.\n\
+ * @return {vec3} The computed diffuse irradiance\n\
+ */\n\
+vec3 getProceduralDiffuseIrradiance(vec3 skyMetrics)\n\
+{\n\
+    vec3 blueSkyDiffuseColor = vec3(0.7, 0.85, 0.9); \n\
+    float diffuseIrradianceFromEarth = (1.0 - skyMetrics.x) * (skyMetrics.y * 0.25 + 0.75) * skyMetrics.z;  \n\
+    float diffuseIrradianceFromSky = (1.0 - skyMetrics.z) * (1.0 - (skyMetrics.y * 0.25 + 0.25));\n\
+    return blueSkyDiffuseColor * clamp(diffuseIrradianceFromEarth + diffuseIrradianceFromSky, 0.0, 1.0);\n\
+}\n\
 \n\
-    // Figure out if the reflection vector hits the ellipsoid\n\
-    float vertexRadius = length(positionWC);\n\
-    float horizonDotNadir = 1.0 - min(1.0, czm_ellipsoidRadii.x / vertexRadius);\n\
-    float reflectionDotNadir = dot(r, normalize(positionWC));\n\
+/**\n\
+ * Compute the specular irradiance for a procedural sky lighting model\n\
+ *\n\
+ * @param {vec3} skyMetrics The dot products of the horizon and reflection directions with the nadir, and an atmosphere boundary distance.\n\
+ * @return {vec3} The computed specular irradiance\n\
+ */\n\
+vec3 getProceduralSpecularIrradiance(vec3 reflectionWC, vec3 skyMetrics, float roughness)\n\
+{\n\
     // Flipping the X vector is a cheap way to get the inverse of czm_temeToPseudoFixed, since that's a rotation about Z.\n\
-    r.x = -r.x;\n\
-    r = -normalize(czm_temeToPseudoFixed * r);\n\
-    r.x = -r.x;\n\
-\n\
-    vec3 diffuseColor = pbrParameters.diffuseColor;\n\
-    float roughness = pbrParameters.roughness;\n\
-    vec3 specularColor = pbrParameters.f0;\n\
+    reflectionWC.x = -reflectionWC.x;\n\
+    reflectionWC = -normalize(czm_temeToPseudoFixed * reflectionWC);\n\
+    reflectionWC.x = -reflectionWC.x;\n\
 \n\
     float inverseRoughness = 1.04 - roughness;\n\
     inverseRoughness *= inverseRoughness;\n\
-    vec3 sceneSkyBox = czm_textureCube(czm_environmentMap, r).rgb * inverseRoughness;\n\
+    vec3 sceneSkyBox = czm_textureCube(czm_environmentMap, reflectionWC).rgb * inverseRoughness;\n\
 \n\
-    float atmosphereHeight = 0.05;\n\
-    float blendRegionSize = 0.1 * ((1.0 - inverseRoughness) * 8.0 + 1.1 - horizonDotNadir);\n\
-    float blendRegionOffset = roughness * -1.0;\n\
-    float farAboveHorizon = clamp(horizonDotNadir - blendRegionSize * 0.5 + blendRegionOffset, 1.0e-10 - blendRegionSize, 0.99999);\n\
-    float aroundHorizon = clamp(horizonDotNadir + blendRegionSize * 0.5, 1.0e-10 - blendRegionSize, 0.99999);\n\
-    float farBelowHorizon = clamp(horizonDotNadir + blendRegionSize * 1.5, 1.0e-10 - blendRegionSize, 0.99999);\n\
-    float smoothstepHeight = smoothstep(0.0, atmosphereHeight, horizonDotNadir);\n\
-    vec3 belowHorizonColor = mix(vec3(0.1, 0.15, 0.25), vec3(0.4, 0.7, 0.9), smoothstepHeight);\n\
+    // Compute colors at different angles relative to the horizon\n\
+    vec3 belowHorizonColor = mix(vec3(0.1, 0.15, 0.25), vec3(0.4, 0.7, 0.9), skyMetrics.z);\n\
     vec3 nadirColor = belowHorizonColor * 0.5;\n\
     vec3 aboveHorizonColor = mix(vec3(0.9, 1.0, 1.2), belowHorizonColor, roughness * 0.5);\n\
-    vec3 blueSkyColor = mix(vec3(0.18, 0.26, 0.48), aboveHorizonColor, reflectionDotNadir * inverseRoughness * 0.5 + 0.75);\n\
-    vec3 zenithColor = mix(blueSkyColor, sceneSkyBox, smoothstepHeight);\n\
-    vec3 blueSkyDiffuseColor = vec3(0.7, 0.85, 0.9); \n\
-    float diffuseIrradianceFromEarth = (1.0 - horizonDotNadir) * (reflectionDotNadir * 0.25 + 0.75) * smoothstepHeight;  \n\
-    float diffuseIrradianceFromSky = (1.0 - smoothstepHeight) * (1.0 - (reflectionDotNadir * 0.25 + 0.25));\n\
-    vec3 diffuseIrradiance = blueSkyDiffuseColor * clamp(diffuseIrradianceFromEarth + diffuseIrradianceFromSky, 0.0, 1.0);\n\
-    float notDistantRough = (1.0 - horizonDotNadir * roughness * 0.8);\n\
-    vec3 specularIrradiance = mix(zenithColor, aboveHorizonColor, smoothstep(farAboveHorizon, aroundHorizon, reflectionDotNadir) * notDistantRough);\n\
-    specularIrradiance = mix(specularIrradiance, belowHorizonColor, smoothstep(aroundHorizon, farBelowHorizon, reflectionDotNadir) * inverseRoughness);\n\
-    specularIrradiance = mix(specularIrradiance, nadirColor, smoothstep(farBelowHorizon, 1.0, reflectionDotNadir) * inverseRoughness);\n\
-\n\
-    // Luminance model from page 40 of http://silviojemma.com/public/papers/lighting/spherical-harmonic-lighting.pdf\n\
-    #ifdef USE_SUN_LUMINANCE \n\
-    // Angle between sun and zenith\n\
-    float LdotZenith = clamp(dot(normalize(czm_inverseViewRotation * l), vWC), 0.001, 1.0);\n\
+    vec3 blueSkyColor = mix(vec3(0.18, 0.26, 0.48), aboveHorizonColor, skyMetrics.y * inverseRoughness * 0.5 + 0.75);\n\
+    vec3 zenithColor = mix(blueSkyColor, sceneSkyBox, skyMetrics.z);\n\
+\n\
+    // Compute blend zones\n\
+    float blendRegionSize = 0.1 * ((1.0 - inverseRoughness) * 8.0 + 1.1 - skyMetrics.x);\n\
+    float blendRegionOffset = roughness * -1.0;\n\
+    float farAboveHorizon = clamp(skyMetrics.x - blendRegionSize * 0.5 + blendRegionOffset, 1.0e-10 - blendRegionSize, 0.99999);\n\
+    float aroundHorizon = clamp(skyMetrics.x + blendRegionSize * 0.5, 1.0e-10 - blendRegionSize, 0.99999);\n\
+    float farBelowHorizon = clamp(skyMetrics.x + blendRegionSize * 1.5, 1.0e-10 - blendRegionSize, 0.99999);\n\
+\n\
+    // Blend colors\n\
+    float notDistantRough = (1.0 - skyMetrics.x * roughness * 0.8);\n\
+    vec3 specularIrradiance = mix(zenithColor, aboveHorizonColor, smoothstep(farAboveHorizon, aroundHorizon, skyMetrics.y) * notDistantRough);\n\
+    specularIrradiance = mix(specularIrradiance, belowHorizonColor, smoothstep(aroundHorizon, farBelowHorizon, skyMetrics.y) * inverseRoughness);\n\
+    specularIrradiance = mix(specularIrradiance, nadirColor, smoothstep(farBelowHorizon, 1.0, skyMetrics.y) * inverseRoughness);\n\
+\n\
+    return specularIrradiance;\n\
+}\n\
+\n\
+#ifdef USE_SUN_LUMINANCE\n\
+float clampedDot(vec3 x, vec3 y)\n\
+{\n\
+    return clamp(dot(x, y), 0.001, 1.0);\n\
+}\n\
+/**\n\
+ * Sun luminance following the \"CIE Clear Sky Model\"\n\
+ * See page 40 of https://3dvar.com/Green2003Spherical.pdf\n\
+ *\n\
+ * @param {vec3} positionWC The position of the fragment in world coordinates.\n\
+ * @param {vec3} normalEC The surface normal in eye coordinates.\n\
+ * @param {vec3} lightDirectionEC Unit vector pointing to the light source in eye coordinates.\n\
+ * @return {float} The computed sun luminance.\n\
+ */\n\
+float getSunLuminance(vec3 positionWC, vec3 normalEC, vec3 lightDirectionEC)\n\
+{\n\
+    vec3 normalWC = normalize(czm_inverseViewRotation * normalEC);\n\
+    vec3 lightDirectionWC = normalize(czm_inverseViewRotation * lightDirectionEC);\n\
+    vec3 vWC = -normalize(positionWC);\n\
+\n\
+    // Angle between sun and zenith.\n\
+    float LdotZenith = clampedDot(lightDirectionWC, vWC);\n\
     float S = acos(LdotZenith);\n\
     // Angle between zenith and current pixel\n\
-    float NdotZenith = clamp(dot(normalize(czm_inverseViewRotation * n), vWC), 0.001, 1.0);\n\
+    float NdotZenith = clampedDot(normalWC, vWC);\n\
     // Angle between sun and current pixel\n\
+    float NdotL = clampedDot(normalEC, lightDirectionEC);\n\
     float gamma = acos(NdotL);\n\
-    float numerator = ((0.91 + 10.0 * exp(-3.0 * gamma) + 0.45 * pow(NdotL, 2.0)) * (1.0 - exp(-0.32 / NdotZenith)));\n\
-    float denominator = (0.91 + 10.0 * exp(-3.0 * S) + 0.45 * pow(LdotZenith,2.0)) * (1.0 - exp(-0.32));\n\
-    float luminance = model_luminanceAtZenith * (numerator / denominator);\n\
-    #endif \n\
 \n\
+    float numerator = ((0.91 + 10.0 * exp(-3.0 * gamma) + 0.45 * NdotL * NdotL) * (1.0 - exp(-0.32 / NdotZenith)));\n\
+    float denominator = (0.91 + 10.0 * exp(-3.0 * S) + 0.45 * LdotZenith * LdotZenith) * (1.0 - exp(-0.32));\n\
+    return model_luminanceAtZenith * (numerator / denominator);\n\
+}\n\
+#endif\n\
+\n\
+/**\n\
+ * Compute the light contribution from a procedural sky model\n\
+ *\n\
+ * @param {vec3} positionEC The position of the fragment in eye coordinates.\n\
+ * @param {vec3} normalEC The surface normal in eye coordinates.\n\
+ * @param {vec3} lightDirectionEC Unit vector pointing to the light source in eye coordinates.\n\
+ * @param {czm_modelMaterial} The material properties.\n\
+ * @return {vec3} The computed HDR color\n\
+ */\n\
+ vec3 proceduralIBL(\n\
+    vec3 positionEC,\n\
+    vec3 normalEC,\n\
+    vec3 lightDirectionEC,\n\
+    czm_modelMaterial material\n\
+) {\n\
+    vec3 viewDirectionEC = -normalize(positionEC);\n\
+    vec3 positionWC = vec3(czm_inverseView * vec4(positionEC, 1.0));\n\
+    vec3 reflectionWC = normalize(czm_inverseViewRotation * normalize(reflect(viewDirectionEC, normalEC)));\n\
+    vec3 skyMetrics = getProceduralSkyMetrics(positionWC, reflectionWC);\n\
+\n\
+    float roughness = material.roughness;\n\
+    vec3 f0 = material.specular;\n\
+\n\
+    vec3 specularIrradiance = getProceduralSpecularIrradiance(reflectionWC, skyMetrics, roughness);\n\
+    float NdotV = abs(dot(normalEC, viewDirectionEC)) + 0.001;\n\
     vec2 brdfLut = texture(czm_brdfLut, vec2(NdotV, roughness)).rg;\n\
-    vec3 iblColor = (diffuseIrradiance * diffuseColor * model_iblFactor.x) + (specularIrradiance * czm_srgbToLinear(specularColor * brdfLut.x + brdfLut.y) * model_iblFactor.y);\n\
-    float maximumComponent = max(max(lightColorHdr.x, lightColorHdr.y), lightColorHdr.z);\n\
-    vec3 lightColor = lightColorHdr / max(maximumComponent, 1.0);\n\
-    iblColor *= lightColor;\n\
+    vec3 specularColor = czm_srgbToLinear(f0 * brdfLut.x + brdfLut.y);\n\
+    vec3 specularContribution = specularIrradiance * specularColor * model_iblFactor.y;\n\
+    #ifdef USE_SPECULAR\n\
+        specularContribution *= material.specularWeight;\n\
+    #endif\n\
+\n\
+    vec3 diffuseIrradiance = getProceduralDiffuseIrradiance(skyMetrics);\n\
+    vec3 diffuseColor = material.diffuse;\n\
+    vec3 diffuseContribution = diffuseIrradiance * diffuseColor * model_iblFactor.x;\n\
 \n\
-    #ifdef USE_SUN_LUMINANCE \n\
-    iblColor *= luminance;\n\
+    vec3 iblColor = specularContribution + diffuseContribution;\n\
+\n\
+    #ifdef USE_SUN_LUMINANCE\n\
+        iblColor *= getSunLuminance(positionWC, normalEC, lightDirectionEC);\n\
     #endif\n\
 \n\
     return iblColor;\n\
 }\n\
 \n\
+#ifdef DIFFUSE_IBL\n\
+vec3 computeDiffuseIBL(vec3 cubeDir)\n\
+{\n\
+    #ifdef CUSTOM_SPHERICAL_HARMONICS\n\
+        return czm_sphericalHarmonics(cubeDir, model_sphericalHarmonicCoefficients); \n\
+    #else\n\
+        return czm_sphericalHarmonics(cubeDir, czm_sphericalHarmonicCoefficients); \n\
+    #endif\n\
+}\n\
+#endif\n\
+\n\
+#ifdef SPECULAR_IBL\n\
+vec3 sampleSpecularEnvironment(vec3 cubeDir, float roughness)\n\
+{\n\
+    #ifdef CUSTOM_SPECULAR_IBL\n\
+        float maxLod = model_specularEnvironmentMapsMaximumLOD;\n\
+        float lod = roughness * maxLod;\n\
+        return czm_sampleOctahedralProjection(model_specularEnvironmentMaps, model_specularEnvironmentMapsSize, cubeDir, lod, maxLod);\n\
+    #else\n\
+        float maxLod = czm_specularEnvironmentMapsMaximumLOD;\n\
+        float lod = roughness * maxLod;\n\
+        return czm_sampleOctahedralProjection(czm_specularEnvironmentMaps, czm_specularEnvironmentMapSize, cubeDir, lod, maxLod);\n\
+    #endif\n\
+}\n\
+vec3 computeSpecularIBL(vec3 cubeDir, float NdotV, float VdotH, vec3 f0, float roughness)\n\
+{\n\
+    float reflectance = czm_maximumComponent(f0);\n\
+    vec3 f90 = vec3(clamp(reflectance * 25.0, 0.0, 1.0));\n\
+    vec3 F = fresnelSchlick2(f0, f90, VdotH);\n\
+\n\
+    vec2 brdfLut = texture(czm_brdfLut, vec2(NdotV, roughness)).rg;\n\
+    vec3 specularSample = sampleSpecularEnvironment(cubeDir, roughness);\n\
+\n\
+    return specularSample * (F * brdfLut.x + brdfLut.y);\n\
+}\n\
+#endif\n\
+\n\
 #if defined(DIFFUSE_IBL) || defined(SPECULAR_IBL)\n\
+/**\n\
+ * Compute the light contributions from environment maps and spherical harmonic coefficients\n\
+ *\n\
+ * @param {vec3} viewDirectionEC Unit vector pointing from the fragment to the eye position\n\
+ * @param {vec3} normalEC The surface normal in eye coordinates\n\
+ * @param {vec3} lightDirectionEC Unit vector pointing to the light source in eye coordinates.\n\
+ * @param {czm_modelMaterial} The material properties.\n\
+ * @return {vec3} The computed HDR color\n\
+ */\n\
 vec3 textureIBL(\n\
-    vec3 positionEC,\n\
+    vec3 viewDirectionEC,\n\
     vec3 normalEC,\n\
     vec3 lightDirectionEC,\n\
-    czm_pbrParameters pbrParameters\n\
+    czm_modelMaterial material\n\
 ) {\n\
-    vec3 diffuseColor = pbrParameters.diffuseColor;\n\
-    float roughness = pbrParameters.roughness;\n\
-    vec3 specularColor = pbrParameters.f0;\n\
-\n\
-    vec3 v = -positionEC;\n\
-    vec3 n = normalEC;\n\
-    vec3 l = normalize(lightDirectionEC);\n\
-    vec3 h = normalize(v + l);\n\
-\n\
-    float NdotV = abs(dot(n, v)) + 0.001;\n\
-    float VdotH = clamp(dot(v, h), 0.0, 1.0);\n\
-\n\
-    const mat3 yUpToZUp = mat3(\n\
-        -1.0, 0.0, 0.0,\n\
-        0.0, 0.0, -1.0, \n\
-        0.0, 1.0, 0.0\n\
-    ); \n\
-    vec3 cubeDir = normalize(yUpToZUp * model_iblReferenceFrameMatrix * normalize(reflect(-v, n))); \n\
-\n\
-    #ifdef DIFFUSE_IBL \n\
-        #ifdef CUSTOM_SPHERICAL_HARMONICS\n\
-        vec3 diffuseIrradiance = czm_sphericalHarmonics(cubeDir, model_sphericalHarmonicCoefficients); \n\
-        #else\n\
-        vec3 diffuseIrradiance = czm_sphericalHarmonics(cubeDir, czm_sphericalHarmonicCoefficients); \n\
-        #endif \n\
-    #else \n\
-    vec3 diffuseIrradiance = vec3(0.0); \n\
-    #endif \n\
+    // Find the direction in which to sample the environment map\n\
+    vec3 cubeDir = normalize(model_iblReferenceFrameMatrix * normalize(reflect(-viewDirectionEC, normalEC)));\n\
+\n\
+    #ifdef DIFFUSE_IBL\n\
+        vec3 diffuseContribution = computeDiffuseIBL(cubeDir) * material.diffuse;\n\
+    #else\n\
+        vec3 diffuseContribution = vec3(0.0); \n\
+    #endif\n\
+\n\
+    float roughness = material.roughness;\n\
+\n\
+    #ifdef USE_ANISOTROPY\n\
+        // Update environment map sampling direction to account for anisotropic distortion of specular reflection\n\
+        vec3 anisotropyDirection = material.anisotropicB;\n\
+        vec3 anisotropicTangent = cross(anisotropyDirection, viewDirectionEC);\n\
+        vec3 anisotropicNormal = cross(anisotropicTangent, anisotropyDirection);\n\
+        float bendFactor = 1.0 - material.anisotropyStrength * (1.0 - roughness);\n\
+        float bendFactorPow4 = bendFactor * bendFactor * bendFactor * bendFactor;\n\
+        vec3 bentNormal = normalize(mix(anisotropicNormal, normalEC, bendFactorPow4));\n\
+        cubeDir = normalize(model_iblReferenceFrameMatrix * normalize(reflect(-viewDirectionEC, bentNormal)));\n\
+    #endif\n\
 \n\
     #ifdef SPECULAR_IBL\n\
-    vec3 r0 = specularColor.rgb;\n\
-    float reflectance = max(max(r0.r, r0.g), r0.b);\n\
-    vec3 r90 = vec3(clamp(reflectance * 25.0, 0.0, 1.0));\n\
-    vec3 F = fresnelSchlick2(r0, r90, VdotH);\n\
-    \n\
-    vec2 brdfLut = texture(czm_brdfLut, vec2(NdotV, roughness)).rg;\n\
-      #ifdef CUSTOM_SPECULAR_IBL \n\
-      vec3 specularIBL = czm_sampleOctahedralProjection(model_specularEnvironmentMaps, model_specularEnvironmentMapsSize, cubeDir, roughness * model_specularEnvironmentMapsMaximumLOD, model_specularEnvironmentMapsMaximumLOD);\n\
-      #else \n\
-      vec3 specularIBL = czm_sampleOctahedralProjection(czm_specularEnvironmentMaps, czm_specularEnvironmentMapSize, cubeDir,  roughness * czm_specularEnvironmentMapsMaximumLOD, czm_specularEnvironmentMapsMaximumLOD);\n\
-      #endif \n\
-    specularIBL *= F * brdfLut.x + brdfLut.y;\n\
-    #else \n\
-    vec3 specularIBL = vec3(0.0); \n\
+        float NdotV = abs(dot(normalEC, viewDirectionEC)) + 0.001;\n\
+        vec3 halfwayDirectionEC = normalize(viewDirectionEC + lightDirectionEC);\n\
+        float VdotH = clamp(dot(viewDirectionEC, halfwayDirectionEC), 0.0, 1.0);\n\
+        vec3 f0 = material.specular;\n\
+        vec3 specularContribution = computeSpecularIBL(cubeDir, NdotV, VdotH, f0, roughness);\n\
+    #else\n\
+        vec3 specularContribution = vec3(0.0); \n\
+    #endif\n\
+\n\
+    #ifdef USE_SPECULAR\n\
+        specularContribution *= material.specularWeight;\n\
     #endif\n\
 \n\
-    return diffuseColor * diffuseIrradiance + specularColor * specularIBL;\n\
+    return diffuseContribution + specularContribution;\n\
 }\n\
 #endif\n\
-\n\
-vec3 imageBasedLightingStage(\n\
-    vec3 positionEC,\n\
-    vec3 normalEC,\n\
-    vec3 lightDirectionEC,\n\
-    vec3 lightColorHdr,\n\
-    czm_pbrParameters pbrParameters\n\
-) {\n\
-  #if defined(DIFFUSE_IBL) || defined(SPECULAR_IBL)\n\
-  // Environment maps were provided, use them for IBL\n\
-  return textureIBL(\n\
-      positionEC,\n\
-      normalEC,\n\
-      lightDirectionEC,\n\
-      pbrParameters\n\
-  );\n\
-  #else\n\
-  // Use the procedural IBL if there are no environment maps\n\
-  return proceduralIBL(\n\
-      positionEC,\n\
-      normalEC,\n\
-      lightDirectionEC,\n\
-      lightColorHdr,\n\
-      pbrParameters\n\
-  );\n\
-  #endif\n\
-}";
+";

package/Source/Shaders/Model/LightingStageFS.glsl

@@ -1,72 +1,137 @@
-#ifdef LIGHTING_PBR
-vec3 computePbrLighting(czm_modelMaterial inputMaterial, ProcessedAttributes attributes)
+#ifdef USE_IBL_LIGHTING
+vec3 computeIBL(vec3 position, vec3 normal, vec3 lightDirection, vec3 lightColorHdr, czm_modelMaterial material)
 {
-    czm_pbrParameters pbrParameters;
-    pbrParameters.diffuseColor = inputMaterial.diffuse;
-    pbrParameters.f0 = inputMaterial.specular;
-    pbrParameters.roughness = inputMaterial.roughness;
-    
-    #ifdef USE_CUSTOM_LIGHT_COLOR
-    vec3 lightColorHdr = model_lightColorHdr;
+    #if defined(DIFFUSE_IBL) || defined(SPECULAR_IBL)
+        // Environment maps were provided, use them for IBL
+        vec3 viewDirection = -normalize(position);
+        vec3 iblColor = textureIBL(viewDirection, normal, lightDirection, material);
     #else
-    vec3 lightColorHdr = czm_lightColorHdr;
+        // Use procedural IBL if there are no environment maps
+        vec3 imageBasedLighting = proceduralIBL(position, normal, lightDirection, material);
+        float maximumComponent = czm_maximumComponent(lightColorHdr);
+        vec3 clampedLightColor = lightColorHdr / max(maximumComponent, 1.0);
+        vec3 iblColor = clampedLightColor * imageBasedLighting;
     #endif
+    return iblColor * material.occlusion;
+}
+#endif
+
+#ifdef USE_CLEARCOAT
+vec3 addClearcoatReflection(vec3 baseLayerColor, vec3 position, vec3 lightDirection, vec3 lightColorHdr, czm_modelMaterial material)
+{
+    vec3 viewDirection = -normalize(position);
+    vec3 halfwayDirection = normalize(viewDirection + lightDirection);
+    vec3 normal = material.clearcoatNormal;
+    float NdotL = clamp(dot(normal, lightDirection), 0.001, 1.0);
+
+    // clearcoatF0 = vec3(pow((ior - 1.0) / (ior + 1.0), 2.0)), but without KHR_materials_ior, ior is a constant 1.5.
+    vec3 f0 = vec3(0.04);
+    vec3 f90 = vec3(1.0);
+    // Note: clearcoat Fresnel computed with dot(n, v) instead of dot(v, h).
+    // This is to make it energy conserving with a simple layering function.
+    float NdotV = clamp(dot(normal, viewDirection), 0.0, 1.0);
+    vec3 F = fresnelSchlick2(f0, f90, NdotV);
 
-    vec3 color = inputMaterial.diffuse;
-    #ifdef HAS_NORMALS
-    color = czm_pbrLighting(
-        attributes.positionEC,
-        inputMaterial.normalEC,
-        czm_lightDirectionEC,
-        lightColorHdr,
-        pbrParameters
-    );
-
-        #ifdef USE_IBL_LIGHTING
-        color += imageBasedLightingStage(
-            attributes.positionEC,
-            inputMaterial.normalEC,
-            czm_lightDirectionEC,
-            lightColorHdr,
-            pbrParameters
-        );
+    // compute specular reflection from direct lighting
+    float roughness = material.clearcoatRoughness;
+    float directStrength = computeDirectSpecularStrength(normal, lightDirection, viewDirection, halfwayDirection, roughness);
+    vec3 directReflection = F * directStrength * NdotL;
+    vec3 color = lightColorHdr * directReflection;
+
+    #ifdef SPECULAR_IBL
+        // Find the direction in which to sample the environment map
+        vec3 cubeDir = normalize(model_iblReferenceFrameMatrix * normalize(reflect(-viewDirection, normal)));
+        vec3 iblColor = computeSpecularIBL(cubeDir, NdotV, NdotV, f0, roughness);
+        color += iblColor * material.occlusion;
+    #elif defined(USE_IBL_LIGHTING)
+        vec3 positionWC = vec3(czm_inverseView * vec4(position, 1.0));
+        vec3 reflectionWC = normalize(czm_inverseViewRotation * normalize(reflect(viewDirection, normal)));
+        vec3 skyMetrics = getProceduralSkyMetrics(positionWC, reflectionWC);
+
+        vec3 specularIrradiance = getProceduralSpecularIrradiance(reflectionWC, skyMetrics, roughness);
+        vec2 brdfLut = texture(czm_brdfLut, vec2(NdotV, roughness)).rg;
+        vec3 specularColor = czm_srgbToLinear(f0 * brdfLut.x + brdfLut.y);
+        vec3 iblColor = specularIrradiance * specularColor * model_iblFactor.y;
+        #ifdef USE_SUN_LUMINANCE
+            iblColor *= getSunLuminance(positionWC, normal, lightDirection);
         #endif
+        float maximumComponent = czm_maximumComponent(lightColorHdr);
+        vec3 clampedLightColor = lightColorHdr / max(maximumComponent, 1.0);
+        color += clampedLightColor* iblColor * material.occlusion;
+    #endif
+
+    float clearcoatFactor = material.clearcoatFactor;
+    vec3 clearcoatColor = color * clearcoatFactor;
+
+    // Dim base layer based on transmission loss through clearcoat
+    return baseLayerColor * (1.0 - clearcoatFactor * F) + clearcoatColor;
+}
+#endif
+
+#if defined(LIGHTING_PBR) && defined(HAS_NORMALS)
+vec3 computePbrLighting(in czm_modelMaterial material, in vec3 position)
+{
+    #ifdef USE_CUSTOM_LIGHT_COLOR
+        vec3 lightColorHdr = model_lightColorHdr;
+    #else
+        vec3 lightColorHdr = czm_lightColorHdr;
     #endif
 
-    color *= inputMaterial.occlusion;
-    color += inputMaterial.emissive;
+    vec3 viewDirection = -normalize(position);
+    vec3 normal = material.normalEC;
+    vec3 lightDirection = normalize(czm_lightDirectionEC);
+
+    vec3 directLighting = czm_pbrLighting(viewDirection, normal, lightDirection, material);
+    vec3 directColor = lightColorHdr * directLighting;
 
-    // In HDR mode, the frame buffer is in linear color space. The
-    // post-processing stages (see PostProcessStageCollection) will handle
-    // tonemapping. However, if HDR is not enabled, we must tonemap else large
-    // values may be clamped to 1.0
-    #ifndef HDR 
-    color = czm_acesTonemapping(color);
-    #endif 
+    // Accumulate colors from base layer
+    vec3 color = directColor + material.emissive;
+    #ifdef USE_IBL_LIGHTING
+        color += computeIBL(position, normal, lightDirection, lightColorHdr, material);
+    #endif
+
+    #ifdef USE_CLEARCOAT
+        color = addClearcoatReflection(color, position, lightDirection, lightColorHdr, material);
+    #endif
 
     return color;
 }
 #endif
 
+/**
+ * Compute the material color under the current lighting conditions.
+ * All other material properties are passed through so further stages
+ * have access to them.
+ *
+ * @param {czm_modelMaterial} material The material properties from {@MaterialStageFS}
+ * @param {ProcessedAttributes} attributes
+ */
 void lightingStage(inout czm_modelMaterial material, ProcessedAttributes attributes)
 {
-    // Even though the lighting will only set the diffuse color,
-    // pass all other properties so further stages have access to them.
-    vec3 color = vec3(0.0);
-
     #ifdef LIGHTING_PBR
-    color = computePbrLighting(material, attributes);
+        #ifdef HAS_NORMALS
+            vec3 color = computePbrLighting(material, attributes.positionEC);
+        #else
+            vec3 color = material.diffuse * material.occlusion + material.emissive;
+        #endif
+        // In HDR mode, the frame buffer is in linear color space. The
+        // post-processing stages (see PostProcessStageCollection) will handle
+        // tonemapping. However, if HDR is not enabled, we must tonemap else large
+        // values may be clamped to 1.0
+        #ifndef HDR
+            color = czm_acesTonemapping(color);
+        #endif
     #else // unlit
-    color = material.diffuse;
+        vec3 color = material.diffuse;
     #endif
 
     #ifdef HAS_POINT_CLOUD_COLOR_STYLE
-    // The colors resulting from point cloud styles are adjusted differently.
-    color = czm_gammaCorrect(color);
+        // The colors resulting from point cloud styles are adjusted differently.
+        color = czm_gammaCorrect(color);
     #elif !defined(HDR)
-    // If HDR is not enabled, the frame buffer stores sRGB colors rather than
-    // linear colors so the linear value must be converted.
-    color = czm_linearToSrgb(color);
+        // If HDR is not enabled, the frame buffer stores sRGB colors rather than
+        // linear colors so the linear value must be converted.
+        color = czm_linearToSrgb(color);
     #endif
 
     material.diffuse = color;