@cesium/engine 10.0.0 → 11.0.0

package/Source/Shaders/BillboardCollectionFS.glsl

@@ -7,6 +7,7 @@ uniform vec4 u_highlightColor;
 in vec2 v_textureCoordinates;
 in vec4 v_pickColor;
 in vec4 v_color;
+in float v_splitDirection;
 
 #ifdef SDF
 in vec4 v_outlineColor;
@@ -86,6 +87,9 @@ vec4 getSDFColor(vec2 position, float outlineWidth, vec4 outlineColor, float smo
 
 void main()
 {
+    if (v_splitDirection < 0.0 && gl_FragCoord.x > czm_splitPosition) discard;
+    if (v_splitDirection > 0.0 && gl_FragCoord.x < czm_splitPosition) discard;
+    
     vec4 color = texture(u_atlas, v_textureCoordinates);
 
 #ifdef SDF

package/Source/Shaders/BillboardCollectionFS.js

@@ -8,6 +8,7 @@ uniform vec4 u_highlightColor;\n\
 in vec2 v_textureCoordinates;\n\
 in vec4 v_pickColor;\n\
 in vec4 v_color;\n\
+in float v_splitDirection;\n\
 \n\
 #ifdef SDF\n\
 in vec4 v_outlineColor;\n\
@@ -87,6 +88,9 @@ vec4 getSDFColor(vec2 position, float outlineWidth, vec4 outlineColor, float smo
 \n\
 void main()\n\
 {\n\
+    if (v_splitDirection < 0.0 && gl_FragCoord.x > czm_splitPosition) discard;\n\
+    if (v_splitDirection > 0.0 && gl_FragCoord.x < czm_splitPosition) discard;\n\
+    \n\
     vec4 color = texture(u_atlas, v_textureCoordinates);\n\
 \n\
 #ifdef SDF\n\

package/Source/Shaders/BillboardCollectionVS.glsl

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

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

@@ -103,6 +103,7 @@ import czm_nearFarScalar from './Functions/nearFarScalar.js'
 import czm_octDecode from './Functions/octDecode.js'
 import czm_packDepth from './Functions/packDepth.js'
 import czm_pbrLighting from './Functions/pbrLighting.js'
+import czm_pbrNeutralTonemapping from './Functions/pbrNeutralTonemapping.js'
 import czm_phong from './Functions/phong.js'
 import czm_planeDistance from './Functions/planeDistance.js'
 import czm_pointAlongRay from './Functions/pointAlongRay.js'
@@ -112,7 +113,6 @@ import czm_readDepth from './Functions/readDepth.js'
 import czm_readNonPerspective from './Functions/readNonPerspective.js'
 import czm_reverseLogDepth from './Functions/reverseLogDepth.js'
 import czm_round from './Functions/round.js'
-import czm_sampleOctahedralProjection from './Functions/sampleOctahedralProjection.js'
 import czm_saturation from './Functions/saturation.js'
 import czm_shadowDepthCompare from './Functions/shadowDepthCompare.js'
 import czm_shadowVisibility from './Functions/shadowVisibility.js'
@@ -241,6 +241,7 @@ export default {
     czm_octDecode : czm_octDecode,
     czm_packDepth : czm_packDepth,
     czm_pbrLighting : czm_pbrLighting,
+    czm_pbrNeutralTonemapping : czm_pbrNeutralTonemapping,
     czm_phong : czm_phong,
     czm_planeDistance : czm_planeDistance,
     czm_pointAlongRay : czm_pointAlongRay,
@@ -250,7 +251,6 @@ export default {
     czm_readNonPerspective : czm_readNonPerspective,
     czm_reverseLogDepth : czm_reverseLogDepth,
     czm_round : czm_round,
-    czm_sampleOctahedralProjection : czm_sampleOctahedralProjection,
     czm_saturation : czm_saturation,
     czm_shadowDepthCompare : czm_shadowDepthCompare,
     czm_shadowVisibility : czm_shadowVisibility,

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 NdotL = clamp(dot(normal, lightDirection), 0.0, 1.0);
+    float NdotV = clamp(dot(normal, viewDirection), 0.0, 1.0);
+    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 NdotL = clamp(dot(normal, lightDirection), 0.0, 1.0);\n\
+    float NdotV = clamp(dot(normal, viewDirection), 0.0, 1.0);\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/pbrNeutralTonemapping.glsl

@@ -0,0 +1,23 @@
+// KhronosGroup https://github.com/KhronosGroup/ToneMapping/tree/main/PBR_Neutral
+
+// Input color is non-negative and resides in the Linear Rec. 709 color space.
+// Output color is also Linear Rec. 709, but in the [0, 1] range.
+
+vec3 czm_pbrNeutralTonemapping(vec3 color) {
+    const float startCompression = 0.8 - 0.04;
+    const float desaturation = 0.15;
+
+    float x = min(color.r, min(color.g, color.b));
+    float offset = czm_branchFreeTernary(x < 0.08, x - 6.25 * x * x, 0.04);
+    color -= offset;
+
+    float peak = max(color.r, max(color.g, color.b));
+    if (peak < startCompression) return color;
+
+    const float d = 1.0 - startCompression;
+    float newPeak = 1.0 - d * d / (peak + d - startCompression);
+    color *= newPeak / peak;
+
+    float g = 1.0 - 1.0 / (desaturation * (peak - newPeak) + 1.0);
+    return mix(color, newPeak * vec3(1.0, 1.0, 1.0), g);
+}

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

@@ -0,0 +1,25 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "// KhronosGroup https://github.com/KhronosGroup/ToneMapping/tree/main/PBR_Neutral\n\
+\n\
+// Input color is non-negative and resides in the Linear Rec. 709 color space.\n\
+// Output color is also Linear Rec. 709, but in the [0, 1] range.\n\
+\n\
+vec3 czm_pbrNeutralTonemapping(vec3 color) {\n\
+    const float startCompression = 0.8 - 0.04;\n\
+    const float desaturation = 0.15;\n\
+\n\
+    float x = min(color.r, min(color.g, color.b));\n\
+    float offset = czm_branchFreeTernary(x < 0.08, x - 6.25 * x * x, 0.04);\n\
+    color -= offset;\n\
+\n\
+    float peak = max(color.r, max(color.g, color.b));\n\
+    if (peak < startCompression) return color;\n\
+\n\
+    const float d = 1.0 - startCompression;\n\
+    float newPeak = 1.0 - d * d / (peak + d - startCompression);\n\
+    color *= newPeak / peak;\n\
+\n\
+    float g = 1.0 - 1.0 / (desaturation * (peak - newPeak) + 1.0);\n\
+    return mix(color, newPeak * vec3(1.0, 1.0, 1.0), g);\n\
+}\n\
+";