@cesium/engine 9.2.0 → 10.1.0

package/Source/Shaders/BillboardCollectionVS.js

@@ -12,6 +12,7 @@ in vec4 scaleByDistance;                            // near, nearScale, far, far
 in vec4 pixelOffsetScaleByDistance;                 // near, nearScale, far, farScale\n\
 in vec4 compressedAttribute3;                       // distance display condition near, far, disableDepthTestDistance, dimensions\n\
 in vec2 sdf;                                        // sdf outline color (rgb) and width (w)\n\
+in float splitDirection;                            // splitDirection\n\
 #if defined(VERTEX_DEPTH_CHECK) || defined(FRAGMENT_DEPTH_CHECK)\n\
 in vec4 textureCoordinateBoundsOrLabelTranslate;    // the min and max x and y values for the texture coordinates\n\
 #endif\n\
@@ -29,6 +30,7 @@ out mat2 v_rotationMatrix;\n\
 \n\
 out vec4 v_pickColor;\n\
 out vec4 v_color;\n\
+out float v_splitDirection;\n\
 #ifdef SDF\n\
 out vec4 v_outlineColor;\n\
 out float v_outlineWidth;\n\
@@ -431,6 +433,6 @@ if (lengthSq < disableDepthTestDistance) {\n\
 \n\
     v_color = color;\n\
     v_color.a *= translucency;\n\
-\n\
+    v_splitDirection = splitDirection;\n\
 }\n\
 ";

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/CzmBuiltins.js

@@ -74,7 +74,7 @@ import czm_decompressTextureCoordinates from './Functions/decompressTextureCoord
 import czm_depthClamp from './Functions/depthClamp.js'
 import czm_eastNorthUpToEyeCoordinates from './Functions/eastNorthUpToEyeCoordinates.js'
 import czm_ellipsoidContainsPoint from './Functions/ellipsoidContainsPoint.js'
-import czm_ellipsoidWgs84TextureCoordinates from './Functions/ellipsoidWgs84TextureCoordinates.js'
+import czm_ellipsoidTextureCoordinates from './Functions/ellipsoidTextureCoordinates.js'
 import czm_equalsEpsilon from './Functions/equalsEpsilon.js'
 import czm_eyeOffset from './Functions/eyeOffset.js'
 import czm_eyeToWindowCoordinates from './Functions/eyeToWindowCoordinates.js'
@@ -212,7 +212,7 @@ export default {
     czm_depthClamp : czm_depthClamp,
     czm_eastNorthUpToEyeCoordinates : czm_eastNorthUpToEyeCoordinates,
     czm_ellipsoidContainsPoint : czm_ellipsoidContainsPoint,
-    czm_ellipsoidWgs84TextureCoordinates : czm_ellipsoidWgs84TextureCoordinates,
+    czm_ellipsoidTextureCoordinates : czm_ellipsoidTextureCoordinates,
     czm_equalsEpsilon : czm_equalsEpsilon,
     czm_eyeOffset : czm_eyeOffset,
     czm_eyeToWindowCoordinates : czm_eyeToWindowCoordinates,

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

@@ -0,0 +1,10 @@
+/**
+ * Approximate uv coordinates based on the ellipsoid normal.
+ *
+ * @name czm_ellipsoidTextureCoordinates
+ * @glslFunction
+ */
+vec2 czm_ellipsoidTextureCoordinates(vec3 normal)
+{
+    return vec2(atan(normal.y, normal.x) * czm_oneOverTwoPi + 0.5, asin(normal.z) * czm_oneOverPi + 0.5);
+}

package/Source/Shaders/Builtin/Functions/{ellipsoidWgs84TextureCoordinates.js → ellipsoidTextureCoordinates.js}

@@ -1,11 +1,11 @@
 //This file is automatically rebuilt by the Cesium build process.
 export default "/**\n\
- * DOC_TBA\n\
+ * Approximate uv coordinates based on the ellipsoid normal.\n\
  *\n\
- * @name czm_ellipsoidWgs84TextureCoordinates\n\
+ * @name czm_ellipsoidTextureCoordinates\n\
  * @glslFunction\n\
  */\n\
-vec2 czm_ellipsoidWgs84TextureCoordinates(vec3 normal)\n\
+vec2 czm_ellipsoidTextureCoordinates(vec3 normal)\n\
 {\n\
     return vec2(atan(normal.y, normal.x) * czm_oneOverTwoPi + 0.5, asin(normal.z) * czm_oneOverPi + 0.5);\n\
 }\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/Builtin/Structs/materialInput.glsl

@@ -10,7 +10,7 @@
  * @property {vec3} normalEC Unperturbed surface normal in eye coordinates.
  * @property {mat3} tangentToEyeMatrix Matrix for converting a tangent space normal to eye space.
  * @property {vec3} positionToEyeEC Vector from the fragment to the eye in eye coordinates.  The magnitude is the distance in meters from the fragment to the eye.
- * @property {float} height The height of the terrain in meters above or below the WGS84 ellipsoid.  Only available for globe materials.
+ * @property {float} height The height of the terrain in meters above or below the ellipsoid.  Only available for globe materials.
  * @property {float} slope The slope of the terrain in radians.  0 is flat; pi/2 is vertical.  Only available for globe materials.
  * @property {float} aspect The aspect of the terrain in radians.  0 is East, pi/2 is North, pi is West, 3pi/2 is South.  Only available for globe materials.
  */

package/Source/Shaders/Builtin/Structs/materialInput.js

@@ -11,7 +11,7 @@ export default "/**\n\
  * @property {vec3} normalEC Unperturbed surface normal in eye coordinates.\n\
  * @property {mat3} tangentToEyeMatrix Matrix for converting a tangent space normal to eye space.\n\
  * @property {vec3} positionToEyeEC Vector from the fragment to the eye in eye coordinates.  The magnitude is the distance in meters from the fragment to the eye.\n\
- * @property {float} height The height of the terrain in meters above or below the WGS84 ellipsoid.  Only available for globe materials.\n\
+ * @property {float} height The height of the terrain in meters above or below the ellipsoid.  Only available for globe materials.\n\
  * @property {float} slope The slope of the terrain in radians.  0 is flat; pi/2 is vertical.  Only available for globe materials.\n\
  * @property {float} aspect The aspect of the terrain in radians.  0 is East, pi/2 is North, pi is West, 3pi/2 is South.  Only available for globe materials.\n\
  */\n\

package/Source/Shaders/Builtin/Structs/modelMaterial.glsl

@@ -10,6 +10,7 @@
  * @name czm_modelMaterial
  * @glslStruct
  *
+ * @property {vec4} baseColor The base color of the material.
  * @property {vec3} diffuse Incoming light that scatters evenly in all directions.
  * @property {float} alpha Alpha of this material. 0.0 is completely transparent; 1.0 is completely opaque.
  * @property {vec3} specular Color of reflected light at normal incidence in PBR materials. This is sometimes referred to as f0 in the literature.
@@ -19,6 +20,7 @@
  * @property {vec3} emissive Light emitted by the material equally in all directions. The default is vec3(0.0), which emits no light.
  */
 struct czm_modelMaterial {
+    vec4 baseColor;
     vec3 diffuse;
     float alpha;
     vec3 specular;

package/Source/Shaders/Builtin/Structs/modelMaterial.js

@@ -11,6 +11,7 @@ export default "/**\n\
  * @name czm_modelMaterial\n\
  * @glslStruct\n\
  *\n\
+ * @property {vec4} baseColor The base color of the material.\n\
  * @property {vec3} diffuse Incoming light that scatters evenly in all directions.\n\
  * @property {float} alpha Alpha of this material. 0.0 is completely transparent; 1.0 is completely opaque.\n\
  * @property {vec3} specular Color of reflected light at normal incidence in PBR materials. This is sometimes referred to as f0 in the literature.\n\
@@ -20,6 +21,7 @@ export default "/**\n\
  * @property {vec3} emissive Light emitted by the material equally in all directions. The default is vec3(0.0), which emits no light.\n\
  */\n\
 struct czm_modelMaterial {\n\
+    vec4 baseColor;\n\
     vec3 diffuse;\n\
     float alpha;\n\
     vec3 specular;\n\

package/Source/Shaders/EllipsoidFS.glsl

@@ -12,7 +12,7 @@ vec4 computeEllipsoidColor(czm_ray ray, float intersection, float side)
     vec3 normalMC = geodeticNormal * side;              // normalized surface normal (always facing the viewer) in model coordinates
     vec3 normalEC = normalize(czm_normal * normalMC);   // normalized surface normal in eye coordinates
 
-    vec2 st = czm_ellipsoidWgs84TextureCoordinates(sphericalNormal);
+    vec2 st = czm_ellipsoidTextureCoordinates(sphericalNormal);
     vec3 positionToEyeEC = -positionEC;
 
     czm_materialInput materialInput;

package/Source/Shaders/EllipsoidFS.js

@@ -13,7 +13,7 @@ vec4 computeEllipsoidColor(czm_ray ray, float intersection, float side)\n\
     vec3 normalMC = geodeticNormal * side;              // normalized surface normal (always facing the viewer) in model coordinates\n\
     vec3 normalEC = normalize(czm_normal * normalMC);   // normalized surface normal in eye coordinates\n\
 \n\
-    vec2 st = czm_ellipsoidWgs84TextureCoordinates(sphericalNormal);\n\
+    vec2 st = czm_ellipsoidTextureCoordinates(sphericalNormal);\n\
     vec3 positionToEyeEC = -positionEC;\n\
 \n\
     czm_materialInput materialInput;\n\

package/Source/Shaders/GlobeFS.glsl

@@ -374,8 +374,8 @@ void main()
     {
         mat3 enuToEye = czm_eastNorthUpToEyeCoordinates(v_positionMC, normalEC);
 
-        vec2 ellipsoidTextureCoordinates = czm_ellipsoidWgs84TextureCoordinates(normalMC);
-        vec2 ellipsoidFlippedTextureCoordinates = czm_ellipsoidWgs84TextureCoordinates(normalMC.zyx);
+        vec2 ellipsoidTextureCoordinates = czm_ellipsoidTextureCoordinates(normalMC);
+        vec2 ellipsoidFlippedTextureCoordinates = czm_ellipsoidTextureCoordinates(normalMC.zyx);
 
         vec2 textureCoordinates = mix(ellipsoidTextureCoordinates, ellipsoidFlippedTextureCoordinates, czm_morphTime * smoothstep(0.9, 0.95, normalMC.z));