@cesium/engine 10.0.0 → 10.1.0

package/Source/Shaders/BrdfLutGeneratorFS.glsl

@@ -27,11 +27,11 @@ vec2 hammersley2D(int i, int N)
     return vec2(float(i) / float(N), vdcRadicalInverse(i));
 }
 
-vec3 importanceSampleGGX(vec2 xi, float roughness, vec3 N)
+vec3 importanceSampleGGX(vec2 xi, float alphaRoughness, vec3 N)
 {
-    float a = roughness * roughness;
+    float alphaRoughnessSquared = alphaRoughness * alphaRoughness;
     float phi = 2.0 * M_PI * xi.x;
-    float cosTheta = sqrt((1.0 - xi.y) / (1.0 + (a * a - 1.0) * xi.y));
+    float cosTheta = sqrt((1.0 - xi.y) / (1.0 + (alphaRoughnessSquared - 1.0) * xi.y));
     float sinTheta = sqrt(1.0 - cosTheta * cosTheta);
     vec3 H = vec3(sinTheta * cos(phi), sinTheta * sin(phi), cosTheta);
     vec3 upVector = abs(N.z) < 0.999 ? vec3(0.0, 0.0, 1.0) : vec3(1.0, 0.0, 0.0);
@@ -40,15 +40,31 @@ vec3 importanceSampleGGX(vec2 xi, float roughness, vec3 N)
     return tangentX * H.x + tangentY * H.y + N * H.z;
 }
 
-float G1_Smith(float NdotV, float k)
+/**
+ * Estimate the geometric self-shadowing of the microfacets in a surface,
+ * using the Smith Joint GGX visibility function.
+ * Note: Vis = G / (4 * NdotL * NdotV)
+ * see Eric Heitz. 2014. Understanding the Masking-Shadowing Function in Microfacet-Based BRDFs. Journal of Computer Graphics Techniques, 3
+ * see Real-Time Rendering. Page 331 to 336.
+ * see https://google.github.io/filament/Filament.md.html#materialsystem/specularbrdf/geometricshadowing(specularg)
+ *
+ * @param {float} alphaRoughness The roughness of the material, expressed as the square of perceptual roughness.
+ * @param {float} NdotL The cosine of the angle between the surface normal and the direction to the light source.
+ * @param {float} NdotV The cosine of the angle between the surface normal and the direction to the camera.
+ */
+float smithVisibilityGGX(float alphaRoughness, float NdotL, float NdotV)
 {
-    return NdotV / (NdotV * (1.0 - k) + k);
-}
+    float alphaRoughnessSq = alphaRoughness * alphaRoughness;
 
-float G_Smith(float roughness, float NdotV, float NdotL)
-{
-    float k = roughness * roughness / 2.0;
-    return G1_Smith(NdotV, k) * G1_Smith(NdotL, k);
+    float GGXV = NdotL * sqrt(NdotV * NdotV * (1.0 - alphaRoughnessSq) + alphaRoughnessSq);
+    float GGXL = NdotV * sqrt(NdotL * NdotL * (1.0 - alphaRoughnessSq) + alphaRoughnessSq);
+
+    float GGX = GGXV + GGXL; // 2.0 if NdotL = NdotV = 1.0
+    if (GGX > 0.0)
+    {
+        return 0.5 / GGX; // 1/4 if NdotL = NdotV = 1.0
+    }
+    return 0.0;
 }
 
 vec2 integrateBrdf(float roughness, float NdotV)
@@ -57,18 +73,19 @@ vec2 integrateBrdf(float roughness, float NdotV)
     float A = 0.0;
     float B = 0.0;
     const int NumSamples = 1024;
+    float alphaRoughness = roughness * roughness;
     for (int i = 0; i < NumSamples; i++)
     {
         vec2 xi = hammersley2D(i, NumSamples);
-        vec3 H = importanceSampleGGX(xi, roughness, vec3(0.0, 0.0, 1.0));
+        vec3 H = importanceSampleGGX(xi, alphaRoughness, vec3(0.0, 0.0, 1.0));
         vec3 L = 2.0 * dot(V, H) * H - V;
         float NdotL = clamp(L.z, 0.0, 1.0);
         float NdotH = clamp(H.z, 0.0, 1.0);
         float VdotH = clamp(dot(V, H), 0.0, 1.0);
         if (NdotL > 0.0)
         {
-            float G = G_Smith(roughness, NdotV, NdotL);
-            float G_Vis = G * VdotH / (NdotH * NdotV);
+            float G = smithVisibilityGGX(alphaRoughness, NdotL, NdotV);
+            float G_Vis = 4.0 * G * VdotH * NdotL / NdotH;
             float Fc = pow(1.0 - VdotH, 5.0);
             A += (1.0 - Fc) * G_Vis;
             B += Fc * G_Vis;

package/Source/Shaders/BrdfLutGeneratorFS.js

@@ -28,11 +28,11 @@ vec2 hammersley2D(int i, int N)\n\
     return vec2(float(i) / float(N), vdcRadicalInverse(i));\n\
 }\n\
 \n\
-vec3 importanceSampleGGX(vec2 xi, float roughness, vec3 N)\n\
+vec3 importanceSampleGGX(vec2 xi, float alphaRoughness, vec3 N)\n\
 {\n\
-    float a = roughness * roughness;\n\
+    float alphaRoughnessSquared = alphaRoughness * alphaRoughness;\n\
     float phi = 2.0 * M_PI * xi.x;\n\
-    float cosTheta = sqrt((1.0 - xi.y) / (1.0 + (a * a - 1.0) * xi.y));\n\
+    float cosTheta = sqrt((1.0 - xi.y) / (1.0 + (alphaRoughnessSquared - 1.0) * xi.y));\n\
     float sinTheta = sqrt(1.0 - cosTheta * cosTheta);\n\
     vec3 H = vec3(sinTheta * cos(phi), sinTheta * sin(phi), cosTheta);\n\
     vec3 upVector = abs(N.z) < 0.999 ? vec3(0.0, 0.0, 1.0) : vec3(1.0, 0.0, 0.0);\n\
@@ -41,15 +41,31 @@ vec3 importanceSampleGGX(vec2 xi, float roughness, vec3 N)\n\
     return tangentX * H.x + tangentY * H.y + N * H.z;\n\
 }\n\
 \n\
-float G1_Smith(float NdotV, float k)\n\
+/**\n\
+ * Estimate the geometric self-shadowing of the microfacets in a surface,\n\
+ * using the Smith Joint GGX visibility function.\n\
+ * Note: Vis = G / (4 * NdotL * NdotV)\n\
+ * see Eric Heitz. 2014. Understanding the Masking-Shadowing Function in Microfacet-Based BRDFs. Journal of Computer Graphics Techniques, 3\n\
+ * see Real-Time Rendering. Page 331 to 336.\n\
+ * see https://google.github.io/filament/Filament.md.html#materialsystem/specularbrdf/geometricshadowing(specularg)\n\
+ *\n\
+ * @param {float} alphaRoughness The roughness of the material, expressed as the square of perceptual roughness.\n\
+ * @param {float} NdotL The cosine of the angle between the surface normal and the direction to the light source.\n\
+ * @param {float} NdotV The cosine of the angle between the surface normal and the direction to the camera.\n\
+ */\n\
+float smithVisibilityGGX(float alphaRoughness, float NdotL, float NdotV)\n\
 {\n\
-    return NdotV / (NdotV * (1.0 - k) + k);\n\
-}\n\
+    float alphaRoughnessSq = alphaRoughness * alphaRoughness;\n\
 \n\
-float G_Smith(float roughness, float NdotV, float NdotL)\n\
-{\n\
-    float k = roughness * roughness / 2.0;\n\
-    return G1_Smith(NdotV, k) * G1_Smith(NdotL, k);\n\
+    float GGXV = NdotL * sqrt(NdotV * NdotV * (1.0 - alphaRoughnessSq) + alphaRoughnessSq);\n\
+    float GGXL = NdotV * sqrt(NdotL * NdotL * (1.0 - alphaRoughnessSq) + alphaRoughnessSq);\n\
+\n\
+    float GGX = GGXV + GGXL; // 2.0 if NdotL = NdotV = 1.0\n\
+    if (GGX > 0.0)\n\
+    {\n\
+        return 0.5 / GGX; // 1/4 if NdotL = NdotV = 1.0\n\
+    }\n\
+    return 0.0;\n\
 }\n\
 \n\
 vec2 integrateBrdf(float roughness, float NdotV)\n\
@@ -58,18 +74,19 @@ vec2 integrateBrdf(float roughness, float NdotV)\n\
     float A = 0.0;\n\
     float B = 0.0;\n\
     const int NumSamples = 1024;\n\
+    float alphaRoughness = roughness * roughness;\n\
     for (int i = 0; i < NumSamples; i++)\n\
     {\n\
         vec2 xi = hammersley2D(i, NumSamples);\n\
-        vec3 H = importanceSampleGGX(xi, roughness, vec3(0.0, 0.0, 1.0));\n\
+        vec3 H = importanceSampleGGX(xi, alphaRoughness, vec3(0.0, 0.0, 1.0));\n\
         vec3 L = 2.0 * dot(V, H) * H - V;\n\
         float NdotL = clamp(L.z, 0.0, 1.0);\n\
         float NdotH = clamp(H.z, 0.0, 1.0);\n\
         float VdotH = clamp(dot(V, H), 0.0, 1.0);\n\
         if (NdotL > 0.0)\n\
         {\n\
-            float G = G_Smith(roughness, NdotV, NdotL);\n\
-            float G_Vis = G * VdotH / (NdotH * NdotV);\n\
+            float G = smithVisibilityGGX(alphaRoughness, NdotL, NdotV);\n\
+            float G_Vis = 4.0 * G * VdotH * NdotL / NdotH;\n\
             float Fc = pow(1.0 - VdotH, 5.0);\n\
             A += (1.0 - Fc) * G_Vis;\n\
             B += Fc * G_Vis;\n\

package/Source/Shaders/Builtin/Functions/pbrLighting.glsl

@@ -13,14 +13,14 @@ vec3 fresnelSchlick2(vec3 f0, vec3 f90, float VdotH)
 
 #ifdef USE_ANISOTROPY
 /**
- * @param {float} roughness Material roughness (along the anisotropy bitangent)
+ * @param {float} bitangentRoughness Material roughness (along the anisotropy bitangent)
  * @param {float} tangentialRoughness Anisotropic roughness (along the anisotropy tangent)
  * @param {vec3} lightDirection The direction from the fragment to the light source, transformed to tangent-bitangent-normal coordinates
  * @param {vec3} viewDirection The direction from the fragment to the camera, transformed to tangent-bitangent-normal coordinates
  */
-float smithVisibilityGGX_anisotropic(float roughness, float tangentialRoughness, vec3 lightDirection, vec3 viewDirection)
+float smithVisibilityGGX_anisotropic(float bitangentRoughness, float tangentialRoughness, vec3 lightDirection, vec3 viewDirection)
 {
-    vec3 roughnessScale = vec3(tangentialRoughness, roughness, 1.0);
+    vec3 roughnessScale = vec3(tangentialRoughness, bitangentRoughness, 1.0);
     float GGXV = lightDirection.z * length(roughnessScale * viewDirection);
     float GGXL = viewDirection.z * length(roughnessScale * lightDirection);
     float v = 0.5 / (GGXV + GGXL);
@@ -28,44 +28,44 @@ float smithVisibilityGGX_anisotropic(float roughness, float tangentialRoughness,
 }
 
 /**
- * @param {float} roughness Material roughness (along the anisotropy bitangent)
+ * @param {float} bitangentRoughness Material roughness (along the anisotropy bitangent)
  * @param {float} tangentialRoughness Anisotropic roughness (along the anisotropy tangent)
  * @param {vec3} halfwayDirection The unit vector halfway between light and view directions, transformed to tangent-bitangent-normal coordinates
  */
-float GGX_anisotropic(float roughness, float tangentialRoughness, vec3 halfwayDirection)
+float GGX_anisotropic(float bitangentRoughness, float tangentialRoughness, vec3 halfwayDirection)
 {
-    float roughnessSquared = roughness * tangentialRoughness;
-    vec3 f = halfwayDirection * vec3(roughness, tangentialRoughness, roughnessSquared);
+    float roughnessSquared = bitangentRoughness * tangentialRoughness;
+    vec3 f = halfwayDirection * vec3(bitangentRoughness, tangentialRoughness, roughnessSquared);
     float w2 = roughnessSquared / dot(f, f);
     return roughnessSquared * w2 * w2 / czm_pi;
 }
 #endif
 
-float smithVisibilityG1(float NdotV, float roughness)
-{
-    // this is the k value for direct lighting.
-    // for image based lighting it will be roughness^2 / 2
-    float k = (roughness + 1.0) * (roughness + 1.0) / 8.0;
-    return NdotV / (NdotV * (1.0 - k) + k);
-}
-
 /**
  * Estimate the geometric self-shadowing of the microfacets in a surface,
- * using the Schlick GGX approximation of a Smith visibility function.
+ * using the Smith Joint GGX visibility function.
+ * Note: Vis = G / (4 * NdotL * NdotV)
+ * see Eric Heitz. 2014. Understanding the Masking-Shadowing Function in Microfacet-Based BRDFs. Journal of Computer Graphics Techniques, 3
+ * see Real-Time Rendering. Page 331 to 336.
+ * see https://google.github.io/filament/Filament.md.html#materialsystem/specularbrdf/geometricshadowing(specularg)
  *
- * @param {float} roughness The roughness of the material.
+ * @param {float} alphaRoughness The roughness of the material, expressed as the square of perceptual roughness.
  * @param {float} NdotL The cosine of the angle between the surface normal and the direction to the light source.
  * @param {float} NdotV The cosine of the angle between the surface normal and the direction to the camera.
  */
-float smithVisibilityGGX(float roughness, float NdotL, float NdotV)
+float smithVisibilityGGX(float alphaRoughness, float NdotL, float NdotV)
 {
-    // Avoid divide-by-zero errors
-    NdotL = clamp(NdotL, 0.001, 1.0);
-    NdotV += 0.001;
-    return (
-        smithVisibilityG1(NdotL, roughness) *
-        smithVisibilityG1(NdotV, roughness)
-    ) / (4.0 * NdotL * NdotV);
+    float alphaRoughnessSq = alphaRoughness * alphaRoughness;
+
+    float GGXV = NdotL * sqrt(NdotV * NdotV * (1.0 - alphaRoughnessSq) + alphaRoughnessSq);
+    float GGXL = NdotV * sqrt(NdotL * NdotL * (1.0 - alphaRoughnessSq) + alphaRoughnessSq);
+
+    float GGX = GGXV + GGXL;
+    if (GGX > 0.0)
+    {
+        return 0.5 / GGX;
+    }
+    return 0.0;
 }
 
 /**
@@ -73,15 +73,15 @@ float smithVisibilityGGX(float roughness, float NdotL, float NdotV)
  * the halfway vector, which is aligned halfway between the directions from
  * the fragment to the camera and from the fragment to the light source.
  *
- * @param {float} roughness The roughness of the material.
+ * @param {float} alphaRoughness The roughness of the material, expressed as the square of perceptual roughness.
  * @param {float} NdotH The cosine of the angle between the surface normal and the halfway vector.
  * @return {float} The fraction of microfacets aligned to the halfway vector.
  */
-float GGX(float roughness, float NdotH)
+float GGX(float alphaRoughness, float NdotH)
 {
-    float roughnessSquared = roughness * roughness;
-    float f = (NdotH * roughnessSquared - NdotH) * NdotH + 1.0;
-    return roughnessSquared / (czm_pi * f * f);
+    float alphaRoughnessSquared = alphaRoughness * alphaRoughness;
+    float f = (NdotH * alphaRoughnessSquared - NdotH) * NdotH + 1.0;
+    return alphaRoughnessSquared / (czm_pi * f * f);
 }
 
 /**
@@ -91,16 +91,16 @@ float GGX(float roughness, float NdotH)
  * @param {vec3} lightDirection The unit vector pointing from the fragment to the light source.
  * @param {vec3} viewDirection The unit vector pointing from the fragment to the camera.
  * @param {vec3} halfwayDirection The unit vector pointing from the fragment to halfway between the light source and the camera.
- * @param {float} roughness The roughness of the material.
+ * @param {float} alphaRoughness The roughness of the material, expressed as the square of perceptual roughness.
  * @return {float} The strength of the specular reflection.
  */
-float computeDirectSpecularStrength(vec3 normal, vec3 lightDirection, vec3 viewDirection, vec3 halfwayDirection, float roughness)
+float computeDirectSpecularStrength(vec3 normal, vec3 lightDirection, vec3 viewDirection, vec3 halfwayDirection, float alphaRoughness)
 {
     float NdotL = dot(normal, lightDirection);
     float NdotV = abs(dot(normal, viewDirection));
-    float G = smithVisibilityGGX(roughness, NdotL, NdotV);
+    float G = smithVisibilityGGX(alphaRoughness, NdotL, NdotV);
     float NdotH = clamp(dot(normal, halfwayDirection), 0.0, 1.0);
-    float D = GGX(roughness, NdotH);
+    float D = GGX(alphaRoughness, NdotH);
     return G * D;
 }
 
@@ -138,19 +138,20 @@ vec3 czm_pbrLighting(vec3 viewDirectionEC, vec3 normalEC, vec3 lightDirectionEC,
         F *= material.specularWeight;
     #endif
 
-    float alpha = material.roughness;
+    float alphaRoughness = material.roughness * material.roughness;
     #ifdef USE_ANISOTROPY
         mat3 tbn = mat3(material.anisotropicT, material.anisotropicB, normalEC);
         vec3 lightDirection = lightDirectionEC * tbn;
         vec3 viewDirection = viewDirectionEC * tbn;
         vec3 halfwayDirection = halfwayDirectionEC * tbn;
         float anisotropyStrength = material.anisotropyStrength;
-        float tangentialRoughness = mix(alpha, 1.0, anisotropyStrength * anisotropyStrength);
-        float G = smithVisibilityGGX_anisotropic(alpha, tangentialRoughness, lightDirection, viewDirection);
-        float D = GGX_anisotropic(alpha, tangentialRoughness, halfwayDirection);
+        float tangentialRoughness = mix(alphaRoughness, 1.0, anisotropyStrength * anisotropyStrength);
+        float bitangentRoughness = clamp(alphaRoughness, 0.001, 1.0);
+        float G = smithVisibilityGGX_anisotropic(bitangentRoughness, tangentialRoughness, lightDirection, viewDirection);
+        float D = GGX_anisotropic(bitangentRoughness, tangentialRoughness, halfwayDirection);
         vec3 specularContribution = F * G * D;
     #else
-        float specularStrength = computeDirectSpecularStrength(normalEC, lightDirectionEC, viewDirectionEC, halfwayDirectionEC, alpha);
+        float specularStrength = computeDirectSpecularStrength(normalEC, lightDirectionEC, viewDirectionEC, halfwayDirectionEC, alphaRoughness);
         vec3 specularContribution = F * specularStrength;
     #endif
 

package/Source/Shaders/Builtin/Functions/pbrLighting.js

@@ -14,14 +14,14 @@ vec3 fresnelSchlick2(vec3 f0, vec3 f90, float VdotH)\n\
 \n\
 #ifdef USE_ANISOTROPY\n\
 /**\n\
- * @param {float} roughness Material roughness (along the anisotropy bitangent)\n\
+ * @param {float} bitangentRoughness Material roughness (along the anisotropy bitangent)\n\
  * @param {float} tangentialRoughness Anisotropic roughness (along the anisotropy tangent)\n\
  * @param {vec3} lightDirection The direction from the fragment to the light source, transformed to tangent-bitangent-normal coordinates\n\
  * @param {vec3} viewDirection The direction from the fragment to the camera, transformed to tangent-bitangent-normal coordinates\n\
  */\n\
-float smithVisibilityGGX_anisotropic(float roughness, float tangentialRoughness, vec3 lightDirection, vec3 viewDirection)\n\
+float smithVisibilityGGX_anisotropic(float bitangentRoughness, float tangentialRoughness, vec3 lightDirection, vec3 viewDirection)\n\
 {\n\
-    vec3 roughnessScale = vec3(tangentialRoughness, roughness, 1.0);\n\
+    vec3 roughnessScale = vec3(tangentialRoughness, bitangentRoughness, 1.0);\n\
     float GGXV = lightDirection.z * length(roughnessScale * viewDirection);\n\
     float GGXL = viewDirection.z * length(roughnessScale * lightDirection);\n\
     float v = 0.5 / (GGXV + GGXL);\n\
@@ -29,44 +29,44 @@ float smithVisibilityGGX_anisotropic(float roughness, float tangentialRoughness,
 }\n\
 \n\
 /**\n\
- * @param {float} roughness Material roughness (along the anisotropy bitangent)\n\
+ * @param {float} bitangentRoughness Material roughness (along the anisotropy bitangent)\n\
  * @param {float} tangentialRoughness Anisotropic roughness (along the anisotropy tangent)\n\
  * @param {vec3} halfwayDirection The unit vector halfway between light and view directions, transformed to tangent-bitangent-normal coordinates\n\
  */\n\
-float GGX_anisotropic(float roughness, float tangentialRoughness, vec3 halfwayDirection)\n\
+float GGX_anisotropic(float bitangentRoughness, float tangentialRoughness, vec3 halfwayDirection)\n\
 {\n\
-    float roughnessSquared = roughness * tangentialRoughness;\n\
-    vec3 f = halfwayDirection * vec3(roughness, tangentialRoughness, roughnessSquared);\n\
+    float roughnessSquared = bitangentRoughness * tangentialRoughness;\n\
+    vec3 f = halfwayDirection * vec3(bitangentRoughness, tangentialRoughness, roughnessSquared);\n\
     float w2 = roughnessSquared / dot(f, f);\n\
     return roughnessSquared * w2 * w2 / czm_pi;\n\
 }\n\
 #endif\n\
 \n\
-float smithVisibilityG1(float NdotV, float roughness)\n\
-{\n\
-    // this is the k value for direct lighting.\n\
-    // for image based lighting it will be roughness^2 / 2\n\
-    float k = (roughness + 1.0) * (roughness + 1.0) / 8.0;\n\
-    return NdotV / (NdotV * (1.0 - k) + k);\n\
-}\n\
-\n\
 /**\n\
  * Estimate the geometric self-shadowing of the microfacets in a surface,\n\
- * using the Schlick GGX approximation of a Smith visibility function.\n\
+ * using the Smith Joint GGX visibility function.\n\
+ * Note: Vis = G / (4 * NdotL * NdotV)\n\
+ * see Eric Heitz. 2014. Understanding the Masking-Shadowing Function in Microfacet-Based BRDFs. Journal of Computer Graphics Techniques, 3\n\
+ * see Real-Time Rendering. Page 331 to 336.\n\
+ * see https://google.github.io/filament/Filament.md.html#materialsystem/specularbrdf/geometricshadowing(specularg)\n\
  *\n\
- * @param {float} roughness The roughness of the material.\n\
+ * @param {float} alphaRoughness The roughness of the material, expressed as the square of perceptual roughness.\n\
  * @param {float} NdotL The cosine of the angle between the surface normal and the direction to the light source.\n\
  * @param {float} NdotV The cosine of the angle between the surface normal and the direction to the camera.\n\
  */\n\
-float smithVisibilityGGX(float roughness, float NdotL, float NdotV)\n\
+float smithVisibilityGGX(float alphaRoughness, float NdotL, float NdotV)\n\
 {\n\
-    // Avoid divide-by-zero errors\n\
-    NdotL = clamp(NdotL, 0.001, 1.0);\n\
-    NdotV += 0.001;\n\
-    return (\n\
-        smithVisibilityG1(NdotL, roughness) *\n\
-        smithVisibilityG1(NdotV, roughness)\n\
-    ) / (4.0 * NdotL * NdotV);\n\
+    float alphaRoughnessSq = alphaRoughness * alphaRoughness;\n\
+\n\
+    float GGXV = NdotL * sqrt(NdotV * NdotV * (1.0 - alphaRoughnessSq) + alphaRoughnessSq);\n\
+    float GGXL = NdotV * sqrt(NdotL * NdotL * (1.0 - alphaRoughnessSq) + alphaRoughnessSq);\n\
+\n\
+    float GGX = GGXV + GGXL;\n\
+    if (GGX > 0.0)\n\
+    {\n\
+        return 0.5 / GGX;\n\
+    }\n\
+    return 0.0;\n\
 }\n\
 \n\
 /**\n\
@@ -74,15 +74,15 @@ float smithVisibilityGGX(float roughness, float NdotL, float NdotV)\n\
  * the halfway vector, which is aligned halfway between the directions from\n\
  * the fragment to the camera and from the fragment to the light source.\n\
  *\n\
- * @param {float} roughness The roughness of the material.\n\
+ * @param {float} alphaRoughness The roughness of the material, expressed as the square of perceptual roughness.\n\
  * @param {float} NdotH The cosine of the angle between the surface normal and the halfway vector.\n\
  * @return {float} The fraction of microfacets aligned to the halfway vector.\n\
  */\n\
-float GGX(float roughness, float NdotH)\n\
+float GGX(float alphaRoughness, float NdotH)\n\
 {\n\
-    float roughnessSquared = roughness * roughness;\n\
-    float f = (NdotH * roughnessSquared - NdotH) * NdotH + 1.0;\n\
-    return roughnessSquared / (czm_pi * f * f);\n\
+    float alphaRoughnessSquared = alphaRoughness * alphaRoughness;\n\
+    float f = (NdotH * alphaRoughnessSquared - NdotH) * NdotH + 1.0;\n\
+    return alphaRoughnessSquared / (czm_pi * f * f);\n\
 }\n\
 \n\
 /**\n\
@@ -92,16 +92,16 @@ float GGX(float roughness, float NdotH)\n\
  * @param {vec3} lightDirection The unit vector pointing from the fragment to the light source.\n\
  * @param {vec3} viewDirection The unit vector pointing from the fragment to the camera.\n\
  * @param {vec3} halfwayDirection The unit vector pointing from the fragment to halfway between the light source and the camera.\n\
- * @param {float} roughness The roughness of the material.\n\
+ * @param {float} alphaRoughness The roughness of the material, expressed as the square of perceptual roughness.\n\
  * @return {float} The strength of the specular reflection.\n\
  */\n\
-float computeDirectSpecularStrength(vec3 normal, vec3 lightDirection, vec3 viewDirection, vec3 halfwayDirection, float roughness)\n\
+float computeDirectSpecularStrength(vec3 normal, vec3 lightDirection, vec3 viewDirection, vec3 halfwayDirection, float alphaRoughness)\n\
 {\n\
     float NdotL = dot(normal, lightDirection);\n\
     float NdotV = abs(dot(normal, viewDirection));\n\
-    float G = smithVisibilityGGX(roughness, NdotL, NdotV);\n\
+    float G = smithVisibilityGGX(alphaRoughness, NdotL, NdotV);\n\
     float NdotH = clamp(dot(normal, halfwayDirection), 0.0, 1.0);\n\
-    float D = GGX(roughness, NdotH);\n\
+    float D = GGX(alphaRoughness, NdotH);\n\
     return G * D;\n\
 }\n\
 \n\
@@ -139,19 +139,20 @@ vec3 czm_pbrLighting(vec3 viewDirectionEC, vec3 normalEC, vec3 lightDirectionEC,
         F *= material.specularWeight;\n\
     #endif\n\
 \n\
-    float alpha = material.roughness;\n\
+    float alphaRoughness = material.roughness * material.roughness;\n\
     #ifdef USE_ANISOTROPY\n\
         mat3 tbn = mat3(material.anisotropicT, material.anisotropicB, normalEC);\n\
         vec3 lightDirection = lightDirectionEC * tbn;\n\
         vec3 viewDirection = viewDirectionEC * tbn;\n\
         vec3 halfwayDirection = halfwayDirectionEC * tbn;\n\
         float anisotropyStrength = material.anisotropyStrength;\n\
-        float tangentialRoughness = mix(alpha, 1.0, anisotropyStrength * anisotropyStrength);\n\
-        float G = smithVisibilityGGX_anisotropic(alpha, tangentialRoughness, lightDirection, viewDirection);\n\
-        float D = GGX_anisotropic(alpha, tangentialRoughness, halfwayDirection);\n\
+        float tangentialRoughness = mix(alphaRoughness, 1.0, anisotropyStrength * anisotropyStrength);\n\
+        float bitangentRoughness = clamp(alphaRoughness, 0.001, 1.0);\n\
+        float G = smithVisibilityGGX_anisotropic(bitangentRoughness, tangentialRoughness, lightDirection, viewDirection);\n\
+        float D = GGX_anisotropic(bitangentRoughness, tangentialRoughness, halfwayDirection);\n\
         vec3 specularContribution = F * G * D;\n\
     #else\n\
-        float specularStrength = computeDirectSpecularStrength(normalEC, lightDirectionEC, viewDirectionEC, halfwayDirectionEC, alpha);\n\
+        float specularStrength = computeDirectSpecularStrength(normalEC, lightDirectionEC, viewDirectionEC, halfwayDirectionEC, alphaRoughness);\n\
         vec3 specularContribution = F * specularStrength;\n\
     #endif\n\
 \n\

package/Source/Shaders/Builtin/Functions/sampleOctahedralProjection.glsl

@@ -68,7 +68,7 @@ vec3 czm_sampleOctahedralProjectionWithFiltering(sampler2D projectedMap, vec2 te
  * @returns {vec3} The color of the cube map at the direction.
  */
 vec3 czm_sampleOctahedralProjection(sampler2D projectedMap, vec2 textureSize, vec3 direction, float lod, float maxLod) {
-    float currentLod = floor(lod + 0.5);
+    float currentLod = floor(lod);
     float nextLod = min(currentLod + 1.0, maxLod);
 
     vec3 colorCurrentLod = czm_sampleOctahedralProjectionWithFiltering(projectedMap, textureSize, direction, currentLod);

package/Source/Shaders/Builtin/Functions/sampleOctahedralProjection.js

@@ -69,7 +69,7 @@ vec3 czm_sampleOctahedralProjectionWithFiltering(sampler2D projectedMap, vec2 te
  * @returns {vec3} The color of the cube map at the direction.\n\
  */\n\
 vec3 czm_sampleOctahedralProjection(sampler2D projectedMap, vec2 textureSize, vec3 direction, float lod, float maxLod) {\n\
-    float currentLod = floor(lod + 0.5);\n\
+    float currentLod = floor(lod);\n\
     float nextLod = min(currentLod + 1.0, maxLod);\n\
 \n\
     vec3 colorCurrentLod = czm_sampleOctahedralProjectionWithFiltering(projectedMap, textureSize, direction, currentLod);\n\

package/Source/Shaders/Model/ImageBasedLightingStageFS.glsl

@@ -16,10 +16,10 @@ vec3 getProceduralSkyMetrics(vec3 positionWC, vec3 reflectionWC)
 }
 
 /**
- * Compute the diffuse irradiance for a procedural sky lighting model
+ * Compute the diffuse irradiance for a procedural sky lighting model.
  *
  * @param {vec3} skyMetrics The dot products of the horizon and reflection directions with the nadir, and an atmosphere boundary distance.
- * @return {vec3} The computed diffuse irradiance
+ * @return {vec3} The computed diffuse irradiance.
  */
 vec3 getProceduralDiffuseIrradiance(vec3 skyMetrics)
 {
@@ -30,10 +30,12 @@ vec3 getProceduralDiffuseIrradiance(vec3 skyMetrics)
 }
 
 /**
- * Compute the specular irradiance for a procedural sky lighting model
+ * Compute the specular irradiance for a procedural sky lighting model.
  *
+ * @param {vec3} reflectionWC The reflection vector in world coordinates.
  * @param {vec3} skyMetrics The dot products of the horizon and reflection directions with the nadir, and an atmosphere boundary distance.
- * @return {vec3} The computed specular irradiance
+ * @param {float} roughness The roughness of the material.
+ * @return {vec3} The computed specular irradiance.
  */
 vec3 getProceduralSpecularIrradiance(vec3 reflectionWC, vec3 skyMetrics, float roughness)
 {
@@ -42,7 +44,7 @@ vec3 getProceduralSpecularIrradiance(vec3 reflectionWC, vec3 skyMetrics, float r
     reflectionWC = -normalize(czm_temeToPseudoFixed * reflectionWC);
     reflectionWC.x = -reflectionWC.x;
 
-    float inverseRoughness = 1.04 - roughness;
+    float inverseRoughness = 1.0 - roughness;
     inverseRoughness *= inverseRoughness;
     vec3 sceneSkyBox = czm_textureCube(czm_environmentMap, reflectionWC).rgb * inverseRoughness;
 
@@ -121,7 +123,7 @@ float getSunLuminance(vec3 positionWC, vec3 normalEC, vec3 lightDirectionEC)
 ) {
     vec3 viewDirectionEC = -normalize(positionEC);
     vec3 positionWC = vec3(czm_inverseView * vec4(positionEC, 1.0));
-    vec3 reflectionWC = normalize(czm_inverseViewRotation * normalize(reflect(viewDirectionEC, normalEC)));
+    vec3 reflectionWC = normalize(czm_inverseViewRotation * reflect(viewDirectionEC, normalEC));
     vec3 skyMetrics = getProceduralSkyMetrics(positionWC, reflectionWC);
 
     float roughness = material.roughness;
@@ -173,11 +175,12 @@ vec3 sampleSpecularEnvironment(vec3 cubeDir, float roughness)
         return czm_sampleOctahedralProjection(czm_specularEnvironmentMaps, czm_specularEnvironmentMapSize, cubeDir, lod, maxLod);
     #endif
 }
-vec3 computeSpecularIBL(vec3 cubeDir, float NdotV, float VdotH, vec3 f0, float roughness)
+vec3 computeSpecularIBL(vec3 cubeDir, float NdotV, vec3 f0, float roughness)
 {
-    float reflectance = czm_maximumComponent(f0);
-    vec3 f90 = vec3(clamp(reflectance * 25.0, 0.0, 1.0));
-    vec3 F = fresnelSchlick2(f0, f90, VdotH);
+    // see https://bruop.github.io/ibl/ at Single Scattering Results
+    // Roughness dependent fresnel, from Fdez-Aguera
+    vec3 f90 = max(vec3(1.0 - roughness), f0);
+    vec3 F = fresnelSchlick2(f0, f90, NdotV);
 
     vec2 brdfLut = texture(czm_brdfLut, vec2(NdotV, roughness)).rg;
     vec3 specularSample = sampleSpecularEnvironment(cubeDir, roughness);
@@ -202,34 +205,31 @@ vec3 textureIBL(
     vec3 lightDirectionEC,
     czm_modelMaterial material
 ) {
-    // Find the direction in which to sample the environment map
-    vec3 cubeDir = normalize(model_iblReferenceFrameMatrix * normalize(reflect(-viewDirectionEC, normalEC)));
-
     #ifdef DIFFUSE_IBL
-        vec3 diffuseContribution = computeDiffuseIBL(cubeDir) * material.diffuse;
+        vec3 normalMC = normalize(model_iblReferenceFrameMatrix * normalEC);
+        vec3 diffuseContribution = computeDiffuseIBL(normalMC) * material.diffuse;
     #else
         vec3 diffuseContribution = vec3(0.0); 
     #endif
 
-    float roughness = material.roughness;
-
     #ifdef USE_ANISOTROPY
-        // Update environment map sampling direction to account for anisotropic distortion of specular reflection
+        // Bend normal to account for anisotropic distortion of specular reflection
         vec3 anisotropyDirection = material.anisotropicB;
         vec3 anisotropicTangent = cross(anisotropyDirection, viewDirectionEC);
         vec3 anisotropicNormal = cross(anisotropicTangent, anisotropyDirection);
-        float bendFactor = 1.0 - material.anisotropyStrength * (1.0 - roughness);
+        float bendFactor = 1.0 - material.anisotropyStrength * (1.0 - material.roughness);
         float bendFactorPow4 = bendFactor * bendFactor * bendFactor * bendFactor;
         vec3 bentNormal = normalize(mix(anisotropicNormal, normalEC, bendFactorPow4));
-        cubeDir = normalize(model_iblReferenceFrameMatrix * normalize(reflect(-viewDirectionEC, bentNormal)));
+        vec3 reflectEC = reflect(-viewDirectionEC, bentNormal);
+    #else
+        vec3 reflectEC = reflect(-viewDirectionEC, normalEC);
     #endif
 
     #ifdef SPECULAR_IBL
-        float NdotV = abs(dot(normalEC, viewDirectionEC)) + 0.001;
-        vec3 halfwayDirectionEC = normalize(viewDirectionEC + lightDirectionEC);
-        float VdotH = clamp(dot(viewDirectionEC, halfwayDirectionEC), 0.0, 1.0);
+        vec3 reflectMC = normalize(model_iblReferenceFrameMatrix * reflectEC);
+        float NdotV = clamp(dot(normalEC, viewDirectionEC), 0.0, 1.0);
         vec3 f0 = material.specular;
-        vec3 specularContribution = computeSpecularIBL(cubeDir, NdotV, VdotH, f0, roughness);
+        vec3 specularContribution = computeSpecularIBL(reflectMC, NdotV, f0, material.roughness);
     #else
         vec3 specularContribution = vec3(0.0); 
     #endif