@cesium/engine 11.0.0 → 12.0.0

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

@@ -30,7 +30,7 @@ vec3 czm_sphericalHarmonics(vec3 normal, vec3 coefficients[9])\n\
     float y = normal.y;\n\
     float z = normal.z;\n\
 \n\
-    return\n\
+    vec3 L =\n\
           L00\n\
         + L1_1 * y\n\
         + L10 * z\n\
@@ -40,5 +40,7 @@ vec3 czm_sphericalHarmonics(vec3 normal, vec3 coefficients[9])\n\
         + L20 * (3.0 * z * z - 1.0)\n\
         + L21 * (z * x)\n\
         + L22 * (x * x - y * y);\n\
+        \n\
+    return max(L, vec3(0.0));\n\
 }\n\
 ";

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

@@ -8,9 +8,9 @@
  *
  * @returns {float} The floating-point depth in [0, 1) range.
  */
- float czm_unpackDepth(vec4 packedDepth)
- {
+float czm_unpackDepth(vec4 packedDepth)
+{
     // See Aras Pranckevičius' post Encoding Floats to RGBA
     // http://aras-p.info/blog/2009/07/30/encoding-floats-to-rgba-the-final/
     return dot(packedDepth, vec4(1.0, 1.0 / 255.0, 1.0 / 65025.0, 1.0 / 16581375.0));
- }
+}

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

@@ -9,10 +9,10 @@ export default "/**\n\
  *\n\
  * @returns {float} The floating-point depth in [0, 1) range.\n\
  */\n\
- float czm_unpackDepth(vec4 packedDepth)\n\
- {\n\
+float czm_unpackDepth(vec4 packedDepth)\n\
+{\n\
     // See Aras Pranckevičius' post Encoding Floats to RGBA\n\
     // http://aras-p.info/blog/2009/07/30/encoding-floats-to-rgba-the-final/\n\
     return dot(packedDepth, vec4(1.0, 1.0 / 255.0, 1.0 / 65025.0, 1.0 / 16581375.0));\n\
- }\n\
+}\n\
 ";

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

@@ -71,7 +71,7 @@ vec4 czm_screenToEyeCoordinates(vec2 screenCoordinateXY, float depthOrLogDepth)
     float near = czm_currentFrustum.x;
     float far = czm_currentFrustum.y;
     float log2Depth = depthOrLogDepth * czm_log2FarDepthFromNearPlusOne;
-    float depthFromNear = pow(2.0, log2Depth) - 1.0;
+    float depthFromNear = exp2(log2Depth) - 1.0;
     float depthFromCamera = depthFromNear + near;
     vec4 screenCoord = vec4(screenCoordinateXY, far * (1.0 - near / depthFromCamera) / (far - near), 1.0);
     vec4 eyeCoordinate = czm_screenToEyeCoordinates(screenCoord);

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

@@ -72,7 +72,7 @@ vec4 czm_screenToEyeCoordinates(vec2 screenCoordinateXY, float depthOrLogDepth)\
     float near = czm_currentFrustum.x;\n\
     float far = czm_currentFrustum.y;\n\
     float log2Depth = depthOrLogDepth * czm_log2FarDepthFromNearPlusOne;\n\
-    float depthFromNear = pow(2.0, log2Depth) - 1.0;\n\
+    float depthFromNear = exp2(log2Depth) - 1.0;\n\
     float depthFromCamera = depthFromNear + near;\n\
     vec4 screenCoord = vec4(screenCoordinateXY, far * (1.0 - near / depthFromCamera) / (far - near), 1.0);\n\
     vec4 eyeCoordinate = czm_screenToEyeCoordinates(screenCoord);\n\

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

@@ -10,7 +10,7 @@ uniform vec2 u_polygonOffset;
 /**
  * Writes the fragment depth to the logarithmic depth buffer.
  * <p>
- * Use this when the vertex shader does not call {@link czm_vertexlogDepth}, for example, when
+ * Use this when the vertex shader does not call {@link czm_vertexLogDepth}, for example, when
  * ray-casting geometry using a full screen quad.
  * </p>
  * @name czm_writeLogDepth
@@ -66,7 +66,7 @@ void czm_writeLogDepth(float depth)
 /**
  * Writes the fragment depth to the logarithmic depth buffer.
  * <p>
- * Use this when the vertex shader calls {@link czm_vertexlogDepth}.
+ * Use this when the vertex shader calls {@link czm_vertexLogDepth}.
  * </p>
  *
  * @name czm_writeLogDepth

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

@@ -11,7 +11,7 @@ uniform vec2 u_polygonOffset;\n\
 /**\n\
  * Writes the fragment depth to the logarithmic depth buffer.\n\
  * <p>\n\
- * Use this when the vertex shader does not call {@link czm_vertexlogDepth}, for example, when\n\
+ * Use this when the vertex shader does not call {@link czm_vertexLogDepth}, for example, when\n\
  * ray-casting geometry using a full screen quad.\n\
  * </p>\n\
  * @name czm_writeLogDepth\n\
@@ -67,7 +67,7 @@ void czm_writeLogDepth(float depth)\n\
 /**\n\
  * Writes the fragment depth to the logarithmic depth buffer.\n\
  * <p>\n\
- * Use this when the vertex shader calls {@link czm_vertexlogDepth}.\n\
+ * Use this when the vertex shader calls {@link czm_vertexLogDepth}.\n\
  * </p>\n\
  *\n\
  * @name czm_writeLogDepth\n\

package/Source/Shaders/ComputeIrradianceFS.glsl

@@ -0,0 +1,103 @@
+uniform samplerCube u_radianceMap;
+
+in vec2 v_textureCoordinates;
+
+
+const float twoSqrtPi = 2.0 * sqrt(czm_pi);
+
+// Coutesy of https://www.ppsloan.org/publications/StupidSH36.pdf
+float computeShBasis(int index, vec3 s) {
+    if (index == 0) { // l = 0, m = 0
+        return 1.0 / twoSqrtPi;
+    }
+    
+    if (index == 1) { // l = 1, m = -1
+        return -sqrt(3.0) * s.y / twoSqrtPi;
+    }
+
+    if (index == 2) { // l = 1, m = 0
+        return sqrt(3.0) * s.z / twoSqrtPi;
+    }
+
+    if (index == 3) { // l = 1, m = 1
+        return -sqrt(3.0) * s.x / twoSqrtPi;
+    }
+
+    if (index == 4) { // l = 2, m = -2
+        return sqrt(15.0) * s.y * s.x / twoSqrtPi;
+    }
+
+    if (index == 5) { // l = 2, m = -1
+        return -sqrt(15.0) * s.y * s.z / twoSqrtPi;
+    }
+
+    if (index == 6) { // l = 2, m = 0
+        return sqrt(5.0) * (3.0 * s.z * s.z - 1.0) / 2.0 / twoSqrtPi;
+    }
+
+    if (index == 7) { // l = 2, m = 1
+        return -sqrt(15.0) * s.x * s.z / twoSqrtPi;
+    }
+
+    if (index == 8) { // l = 2, m = 2
+        return sqrt(15.0) * (s.x * s.x - s.y * s.y) / 2.0 / twoSqrtPi;
+    }
+
+    return 0.0;
+}
+
+float vdcRadicalInverse(int i)
+{
+    float r;
+    float base = 2.0;
+    float value = 0.0;
+    float invBase = 1.0 / base;
+    float invBi = invBase;
+    for (int x = 0; x < 100; x++)
+    {
+        if (i <= 0)
+        {
+            break;
+        }
+        r = mod(float(i), base);
+        value += r * invBi;
+        invBi *= invBase;
+        i = int(float(i) * invBase);
+    }
+    return value;
+}
+
+vec2 hammersley2D(int i, int N)
+{
+    return vec2(float(i) / float(N), vdcRadicalInverse(i));
+}
+
+// Sample count is relatively low for the sake of performance, but should still be enough to capture directionality needed for third-order harmonics
+const int samples = 256; 
+const float solidAngle = 1.0 / float(samples);
+
+void main() {
+    // Get the current coefficient based on the uv
+   vec2 uv = v_textureCoordinates.xy * 3.0;
+   int coefficientIndex = int(floor(uv.y) * 3.0 + floor(uv.x));
+
+    for (int i = 0; i < samples; ++i) {
+        vec2 xi = hammersley2D(i, samples);
+        float phi = czm_twoPi * xi.x;
+        float cosTheta = 1.0 - 2.0 * sqrt(1.0 - xi.y * xi.y);
+        float sinTheta = sqrt(1.0 - cosTheta * cosTheta);
+        vec3 direction = normalize(vec3(sinTheta * cos(phi), cosTheta, sinTheta * sin(phi)));
+
+        // Generate the spherical harmonics basis from the direction
+        float Ylm = computeShBasis(coefficientIndex, direction);
+
+        vec3 lookupDirection = -direction.xyz;
+        lookupDirection.z = -lookupDirection.z;
+
+        vec4 color = czm_textureCube(u_radianceMap, lookupDirection, 0.0);
+
+        // Use the relevant function for this coefficient
+        out_FragColor += Ylm * color * solidAngle * sinTheta;
+    }
+    
+}

package/Source/Shaders/ComputeIrradianceFS.js

@@ -0,0 +1,105 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "uniform samplerCube u_radianceMap;\n\
+\n\
+in vec2 v_textureCoordinates;\n\
+\n\
+\n\
+const float twoSqrtPi = 2.0 * sqrt(czm_pi);\n\
+\n\
+// Coutesy of https://www.ppsloan.org/publications/StupidSH36.pdf\n\
+float computeShBasis(int index, vec3 s) {\n\
+    if (index == 0) { // l = 0, m = 0\n\
+        return 1.0 / twoSqrtPi;\n\
+    }\n\
+    \n\
+    if (index == 1) { // l = 1, m = -1\n\
+        return -sqrt(3.0) * s.y / twoSqrtPi;\n\
+    }\n\
+\n\
+    if (index == 2) { // l = 1, m = 0\n\
+        return sqrt(3.0) * s.z / twoSqrtPi;\n\
+    }\n\
+\n\
+    if (index == 3) { // l = 1, m = 1\n\
+        return -sqrt(3.0) * s.x / twoSqrtPi;\n\
+    }\n\
+\n\
+    if (index == 4) { // l = 2, m = -2\n\
+        return sqrt(15.0) * s.y * s.x / twoSqrtPi;\n\
+    }\n\
+\n\
+    if (index == 5) { // l = 2, m = -1\n\
+        return -sqrt(15.0) * s.y * s.z / twoSqrtPi;\n\
+    }\n\
+\n\
+    if (index == 6) { // l = 2, m = 0\n\
+        return sqrt(5.0) * (3.0 * s.z * s.z - 1.0) / 2.0 / twoSqrtPi;\n\
+    }\n\
+\n\
+    if (index == 7) { // l = 2, m = 1\n\
+        return -sqrt(15.0) * s.x * s.z / twoSqrtPi;\n\
+    }\n\
+\n\
+    if (index == 8) { // l = 2, m = 2\n\
+        return sqrt(15.0) * (s.x * s.x - s.y * s.y) / 2.0 / twoSqrtPi;\n\
+    }\n\
+\n\
+    return 0.0;\n\
+}\n\
+\n\
+float vdcRadicalInverse(int i)\n\
+{\n\
+    float r;\n\
+    float base = 2.0;\n\
+    float value = 0.0;\n\
+    float invBase = 1.0 / base;\n\
+    float invBi = invBase;\n\
+    for (int x = 0; x < 100; x++)\n\
+    {\n\
+        if (i <= 0)\n\
+        {\n\
+            break;\n\
+        }\n\
+        r = mod(float(i), base);\n\
+        value += r * invBi;\n\
+        invBi *= invBase;\n\
+        i = int(float(i) * invBase);\n\
+    }\n\
+    return value;\n\
+}\n\
+\n\
+vec2 hammersley2D(int i, int N)\n\
+{\n\
+    return vec2(float(i) / float(N), vdcRadicalInverse(i));\n\
+}\n\
+\n\
+// Sample count is relatively low for the sake of performance, but should still be enough to capture directionality needed for third-order harmonics\n\
+const int samples = 256; \n\
+const float solidAngle = 1.0 / float(samples);\n\
+\n\
+void main() {\n\
+    // Get the current coefficient based on the uv\n\
+   vec2 uv = v_textureCoordinates.xy * 3.0;\n\
+   int coefficientIndex = int(floor(uv.y) * 3.0 + floor(uv.x));\n\
+\n\
+    for (int i = 0; i < samples; ++i) {\n\
+        vec2 xi = hammersley2D(i, samples);\n\
+        float phi = czm_twoPi * xi.x;\n\
+        float cosTheta = 1.0 - 2.0 * sqrt(1.0 - xi.y * xi.y);\n\
+        float sinTheta = sqrt(1.0 - cosTheta * cosTheta);\n\
+        vec3 direction = normalize(vec3(sinTheta * cos(phi), cosTheta, sinTheta * sin(phi)));\n\
+\n\
+        // Generate the spherical harmonics basis from the direction\n\
+        float Ylm = computeShBasis(coefficientIndex, direction);\n\
+\n\
+        vec3 lookupDirection = -direction.xyz;\n\
+        lookupDirection.z = -lookupDirection.z;\n\
+\n\
+        vec4 color = czm_textureCube(u_radianceMap, lookupDirection, 0.0);\n\
+\n\
+        // Use the relevant function for this coefficient\n\
+        out_FragColor += Ylm * color * solidAngle * sinTheta;\n\
+    }\n\
+    \n\
+}\n\
+";

package/Source/Shaders/ComputeRadianceMapFS.glsl

@@ -0,0 +1,107 @@
+precision highp float;
+
+in vec2 v_textureCoordinates;
+
+uniform vec3 u_faceDirection; // Current cubemap face
+uniform vec3 u_positionWC;
+uniform mat4 u_enuToFixedFrame;
+uniform vec4 u_brightnessSaturationGammaIntensity;
+uniform vec4 u_groundColor; // alpha component represent albedo
+
+vec4 getCubeMapDirection(vec2 uv, vec3 faceDir) {
+    vec2 scaledUV = uv * 2.0 - 1.0;
+
+    if (faceDir.x != 0.0) {
+        return vec4(faceDir.x,  scaledUV.x * faceDir.x, -scaledUV.y, 0.0);
+    } else if (faceDir.y != 0.0) {
+        return vec4(scaledUV.x, -scaledUV.y * faceDir.y, faceDir.y, 0.0);
+    } else {
+        return vec4(scaledUV.x * faceDir.z, -faceDir.z, -scaledUV.y, 0.0); 
+    }
+}
+
+void main() {    
+    float height = length(u_positionWC);
+    float atmosphereInnerRadius = u_radiiAndDynamicAtmosphereColor.y;
+    float ellipsoidHeight = max(height - atmosphereInnerRadius, 0.0);
+
+    // Scale the position to ensure the sky color is present, even when underground.
+    vec3 positionWC = u_positionWC / height * (ellipsoidHeight + atmosphereInnerRadius);
+
+    float atmosphereOuterRadius = u_radiiAndDynamicAtmosphereColor.x;
+    float atmosphereHeight = atmosphereOuterRadius - atmosphereInnerRadius;
+
+    vec3 direction = (u_enuToFixedFrame * getCubeMapDirection(v_textureCoordinates, u_faceDirection)).xyz;
+    vec3 normalizedDirection = normalize(direction);
+
+    czm_ray ray = czm_ray(positionWC, normalizedDirection);
+    czm_raySegment intersection = czm_raySphereIntersectionInterval(ray, vec3(0.0), atmosphereInnerRadius);
+    if (!czm_isEmpty(intersection)) {
+        intersection = czm_rayEllipsoidIntersectionInterval(ray, vec3(0.0), czm_ellipsoidInverseRadii);
+    }
+
+    bool onEllipsoid = intersection.start >= 0.0;
+    float rayLength = czm_branchFreeTernary(onEllipsoid, intersection.start, atmosphereOuterRadius);
+
+    // Compute sky color for each position on a sphere at radius centered around the provided position's origin
+    vec3 skyPositionWC = positionWC + normalizedDirection * rayLength;
+
+    float lightEnum = u_radiiAndDynamicAtmosphereColor.z;
+    vec3 lightDirectionWC = normalize(czm_getDynamicAtmosphereLightDirection(skyPositionWC, lightEnum));
+    vec3 mieColor;
+    vec3 rayleighColor;
+    float opacity;
+    czm_computeScattering(
+        ray,
+        rayLength,
+        lightDirectionWC,
+        atmosphereInnerRadius, 
+        rayleighColor,
+        mieColor,
+        opacity
+    );
+
+    vec4 atmopshereColor = czm_computeAtmosphereColor(ray, lightDirectionWC, rayleighColor, mieColor, opacity);
+
+#ifdef ATMOSPHERE_COLOR_CORRECT
+    const bool ignoreBlackPixels = true;
+    atmopshereColor.rgb = czm_applyHSBShift(atmopshereColor.rgb, czm_atmosphereHsbShift, ignoreBlackPixels);
+#endif
+
+    vec3 lookupDirection = -normalizedDirection;
+     // Flipping the X vector is a cheap way to get the inverse of czm_temeToPseudoFixed, since that's a rotation about Z.
+    lookupDirection.x = -lookupDirection.x;
+    lookupDirection = -normalize(czm_temeToPseudoFixed * lookupDirection);
+    lookupDirection.x = -lookupDirection.x;
+
+    // Values outside the atmopshere are rendered as black, when they should be treated as transparent
+    float skyAlpha = clamp((1.0 - ellipsoidHeight / atmosphereHeight) * atmopshereColor.a, 0.0, 1.0);
+    skyAlpha = czm_branchFreeTernary(length(atmopshereColor.rgb) <= czm_epsilon7, 0.0, skyAlpha); // Treat black as transparent
+
+    // Blend starmap with atmopshere scattering
+    float intensity = u_brightnessSaturationGammaIntensity.w;
+    vec4 sceneSkyBoxColor = czm_textureCube(czm_environmentMap, lookupDirection);
+    vec3 skyBackgroundColor = mix(czm_backgroundColor.rgb, sceneSkyBoxColor.rgb, sceneSkyBoxColor.a);
+    vec4 combinedSkyColor = vec4(mix(skyBackgroundColor, atmopshereColor.rgb * intensity, skyAlpha), 1.0);
+
+    // Compute ground color based on amount of reflected light, then blend it with ground atmosphere based on height
+    vec3 up = normalize(positionWC);
+    float occlusion = max(dot(lightDirectionWC, up), 0.05);
+    vec4 groundColor = vec4(u_groundColor.rgb * u_groundColor.a * (vec3(intensity * occlusion) + atmopshereColor.rgb), 1.0);
+    vec4 blendedGroundColor = mix(groundColor, atmopshereColor, clamp(ellipsoidHeight / atmosphereHeight, 0.0, 1.0));
+
+    vec4 color = czm_branchFreeTernary(onEllipsoid, blendedGroundColor, combinedSkyColor);
+
+    float brightness = u_brightnessSaturationGammaIntensity.x;
+    float saturation = u_brightnessSaturationGammaIntensity.y;
+    float gamma = u_brightnessSaturationGammaIntensity.z;
+
+#ifdef ENVIRONMENT_COLOR_CORRECT
+    color.rgb = mix(vec3(0.0), color.rgb, brightness);
+    color.rgb = czm_saturation(color.rgb, saturation);
+#endif
+    color.rgb = pow(color.rgb, vec3(gamma)); // Normally this would be in the ifdef above, but there is a precision issue with the atmopshere scattering transmittance (alpha). Having this line is a workaround for that issue, even when gamma is 1.0.
+    color.rgb = czm_gammaCorrect(color.rgb);
+
+    out_FragColor = color;
+}

package/Source/Shaders/ComputeRadianceMapFS.js

@@ -0,0 +1,109 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "precision highp float;\n\
+\n\
+in vec2 v_textureCoordinates;\n\
+\n\
+uniform vec3 u_faceDirection; // Current cubemap face\n\
+uniform vec3 u_positionWC;\n\
+uniform mat4 u_enuToFixedFrame;\n\
+uniform vec4 u_brightnessSaturationGammaIntensity;\n\
+uniform vec4 u_groundColor; // alpha component represent albedo\n\
+\n\
+vec4 getCubeMapDirection(vec2 uv, vec3 faceDir) {\n\
+    vec2 scaledUV = uv * 2.0 - 1.0;\n\
+\n\
+    if (faceDir.x != 0.0) {\n\
+        return vec4(faceDir.x,  scaledUV.x * faceDir.x, -scaledUV.y, 0.0);\n\
+    } else if (faceDir.y != 0.0) {\n\
+        return vec4(scaledUV.x, -scaledUV.y * faceDir.y, faceDir.y, 0.0);\n\
+    } else {\n\
+        return vec4(scaledUV.x * faceDir.z, -faceDir.z, -scaledUV.y, 0.0); \n\
+    }\n\
+}\n\
+\n\
+void main() {    \n\
+    float height = length(u_positionWC);\n\
+    float atmosphereInnerRadius = u_radiiAndDynamicAtmosphereColor.y;\n\
+    float ellipsoidHeight = max(height - atmosphereInnerRadius, 0.0);\n\
+\n\
+    // Scale the position to ensure the sky color is present, even when underground.\n\
+    vec3 positionWC = u_positionWC / height * (ellipsoidHeight + atmosphereInnerRadius);\n\
+\n\
+    float atmosphereOuterRadius = u_radiiAndDynamicAtmosphereColor.x;\n\
+    float atmosphereHeight = atmosphereOuterRadius - atmosphereInnerRadius;\n\
+\n\
+    vec3 direction = (u_enuToFixedFrame * getCubeMapDirection(v_textureCoordinates, u_faceDirection)).xyz;\n\
+    vec3 normalizedDirection = normalize(direction);\n\
+\n\
+    czm_ray ray = czm_ray(positionWC, normalizedDirection);\n\
+    czm_raySegment intersection = czm_raySphereIntersectionInterval(ray, vec3(0.0), atmosphereInnerRadius);\n\
+    if (!czm_isEmpty(intersection)) {\n\
+        intersection = czm_rayEllipsoidIntersectionInterval(ray, vec3(0.0), czm_ellipsoidInverseRadii);\n\
+    }\n\
+\n\
+    bool onEllipsoid = intersection.start >= 0.0;\n\
+    float rayLength = czm_branchFreeTernary(onEllipsoid, intersection.start, atmosphereOuterRadius);\n\
+\n\
+    // Compute sky color for each position on a sphere at radius centered around the provided position's origin\n\
+    vec3 skyPositionWC = positionWC + normalizedDirection * rayLength;\n\
+\n\
+    float lightEnum = u_radiiAndDynamicAtmosphereColor.z;\n\
+    vec3 lightDirectionWC = normalize(czm_getDynamicAtmosphereLightDirection(skyPositionWC, lightEnum));\n\
+    vec3 mieColor;\n\
+    vec3 rayleighColor;\n\
+    float opacity;\n\
+    czm_computeScattering(\n\
+        ray,\n\
+        rayLength,\n\
+        lightDirectionWC,\n\
+        atmosphereInnerRadius, \n\
+        rayleighColor,\n\
+        mieColor,\n\
+        opacity\n\
+    );\n\
+\n\
+    vec4 atmopshereColor = czm_computeAtmosphereColor(ray, lightDirectionWC, rayleighColor, mieColor, opacity);\n\
+\n\
+#ifdef ATMOSPHERE_COLOR_CORRECT\n\
+    const bool ignoreBlackPixels = true;\n\
+    atmopshereColor.rgb = czm_applyHSBShift(atmopshereColor.rgb, czm_atmosphereHsbShift, ignoreBlackPixels);\n\
+#endif\n\
+\n\
+    vec3 lookupDirection = -normalizedDirection;\n\
+     // Flipping the X vector is a cheap way to get the inverse of czm_temeToPseudoFixed, since that's a rotation about Z.\n\
+    lookupDirection.x = -lookupDirection.x;\n\
+    lookupDirection = -normalize(czm_temeToPseudoFixed * lookupDirection);\n\
+    lookupDirection.x = -lookupDirection.x;\n\
+\n\
+    // Values outside the atmopshere are rendered as black, when they should be treated as transparent\n\
+    float skyAlpha = clamp((1.0 - ellipsoidHeight / atmosphereHeight) * atmopshereColor.a, 0.0, 1.0);\n\
+    skyAlpha = czm_branchFreeTernary(length(atmopshereColor.rgb) <= czm_epsilon7, 0.0, skyAlpha); // Treat black as transparent\n\
+\n\
+    // Blend starmap with atmopshere scattering\n\
+    float intensity = u_brightnessSaturationGammaIntensity.w;\n\
+    vec4 sceneSkyBoxColor = czm_textureCube(czm_environmentMap, lookupDirection);\n\
+    vec3 skyBackgroundColor = mix(czm_backgroundColor.rgb, sceneSkyBoxColor.rgb, sceneSkyBoxColor.a);\n\
+    vec4 combinedSkyColor = vec4(mix(skyBackgroundColor, atmopshereColor.rgb * intensity, skyAlpha), 1.0);\n\
+\n\
+    // Compute ground color based on amount of reflected light, then blend it with ground atmosphere based on height\n\
+    vec3 up = normalize(positionWC);\n\
+    float occlusion = max(dot(lightDirectionWC, up), 0.05);\n\
+    vec4 groundColor = vec4(u_groundColor.rgb * u_groundColor.a * (vec3(intensity * occlusion) + atmopshereColor.rgb), 1.0);\n\
+    vec4 blendedGroundColor = mix(groundColor, atmopshereColor, clamp(ellipsoidHeight / atmosphereHeight, 0.0, 1.0));\n\
+\n\
+    vec4 color = czm_branchFreeTernary(onEllipsoid, blendedGroundColor, combinedSkyColor);\n\
+\n\
+    float brightness = u_brightnessSaturationGammaIntensity.x;\n\
+    float saturation = u_brightnessSaturationGammaIntensity.y;\n\
+    float gamma = u_brightnessSaturationGammaIntensity.z;\n\
+\n\
+#ifdef ENVIRONMENT_COLOR_CORRECT\n\
+    color.rgb = mix(vec3(0.0), color.rgb, brightness);\n\
+    color.rgb = czm_saturation(color.rgb, saturation);\n\
+#endif\n\
+    color.rgb = pow(color.rgb, vec3(gamma)); // Normally this would be in the ifdef above, but there is a precision issue with the atmopshere scattering transmittance (alpha). Having this line is a workaround for that issue, even when gamma is 1.0.\n\
+    color.rgb = czm_gammaCorrect(color.rgb);\n\
+\n\
+    out_FragColor = color;\n\
+}\n\
+";

package/Source/Shaders/ConvolveSpecularMapFS.glsl

@@ -0,0 +1,70 @@
+precision highp float;
+
+in vec3 v_textureCoordinates;
+
+uniform float u_roughness;
+uniform samplerCube u_radianceTexture;
+uniform vec3 u_faceDirection;
+
+float vdcRadicalInverse(int i)
+{
+    float r;
+    float base = 2.0;
+    float value = 0.0;
+    float invBase = 1.0 / base;
+    float invBi = invBase;
+    for (int x = 0; x < 100; x++)
+    {
+        if (i <= 0)
+        {
+            break;
+        }
+        r = mod(float(i), base);
+        value += r * invBi;
+        invBi *= invBase;
+        i = int(float(i) * invBase);
+    }
+    return value;
+}
+
+vec2 hammersley2D(int i, int N)
+{
+    return vec2(float(i) / float(N), vdcRadicalInverse(i));
+}
+
+vec3 importanceSampleGGX(vec2 xi, float alphaRoughness, vec3 N)
+{
+    float alphaRoughnessSquared = alphaRoughness * alphaRoughness;
+    float phi = czm_twoPi * xi.x;
+    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);
+    vec3 tangentX = normalize(cross(upVector, N));
+    vec3 tangentY = cross(N, tangentX);
+    return tangentX * H.x + tangentY * H.y + N * H.z;
+}
+
+// Sample count is relatively low for the sake of performance, but should still be enough to prevent artifacting in lower roughnesses
+const int samples = 128;
+
+void main() {
+    vec3 normal = u_faceDirection;
+    vec3 V = normalize(v_textureCoordinates);
+    float roughness = u_roughness;
+
+    vec4 color = vec4(0.0);
+    float weight = 0.0;
+    for (int i = 0; i < samples; ++i) {
+            vec2 xi = hammersley2D(i, samples);
+            vec3 H = importanceSampleGGX(xi, roughness, V);
+            vec3 L = 2.0 * dot(V, H) * H - V; // reflected vector
+
+            float NdotL = max(dot(V, L), 0.0);
+            if (NdotL > 0.0) {
+                color += vec4(texture(u_radianceTexture, L).rgb, 1.0) * NdotL;
+                weight += NdotL;
+            }
+        }
+    out_FragColor = color / weight;
+}

package/Source/Shaders/ConvolveSpecularMapFS.js

@@ -0,0 +1,72 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "precision highp float;\n\
+\n\
+in vec3 v_textureCoordinates;\n\
+\n\
+uniform float u_roughness;\n\
+uniform samplerCube u_radianceTexture;\n\
+uniform vec3 u_faceDirection;\n\
+\n\
+float vdcRadicalInverse(int i)\n\
+{\n\
+    float r;\n\
+    float base = 2.0;\n\
+    float value = 0.0;\n\
+    float invBase = 1.0 / base;\n\
+    float invBi = invBase;\n\
+    for (int x = 0; x < 100; x++)\n\
+    {\n\
+        if (i <= 0)\n\
+        {\n\
+            break;\n\
+        }\n\
+        r = mod(float(i), base);\n\
+        value += r * invBi;\n\
+        invBi *= invBase;\n\
+        i = int(float(i) * invBase);\n\
+    }\n\
+    return value;\n\
+}\n\
+\n\
+vec2 hammersley2D(int i, int N)\n\
+{\n\
+    return vec2(float(i) / float(N), vdcRadicalInverse(i));\n\
+}\n\
+\n\
+vec3 importanceSampleGGX(vec2 xi, float alphaRoughness, vec3 N)\n\
+{\n\
+    float alphaRoughnessSquared = alphaRoughness * alphaRoughness;\n\
+    float phi = czm_twoPi * xi.x;\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\
+    vec3 tangentX = normalize(cross(upVector, N));\n\
+    vec3 tangentY = cross(N, tangentX);\n\
+    return tangentX * H.x + tangentY * H.y + N * H.z;\n\
+}\n\
+\n\
+// Sample count is relatively low for the sake of performance, but should still be enough to prevent artifacting in lower roughnesses\n\
+const int samples = 128;\n\
+\n\
+void main() {\n\
+    vec3 normal = u_faceDirection;\n\
+    vec3 V = normalize(v_textureCoordinates);\n\
+    float roughness = u_roughness;\n\
+\n\
+    vec4 color = vec4(0.0);\n\
+    float weight = 0.0;\n\
+    for (int i = 0; i < samples; ++i) {\n\
+            vec2 xi = hammersley2D(i, samples);\n\
+            vec3 H = importanceSampleGGX(xi, roughness, V);\n\
+            vec3 L = 2.0 * dot(V, H) * H - V; // reflected vector\n\
+\n\
+            float NdotL = max(dot(V, L), 0.0);\n\
+            if (NdotL > 0.0) {\n\
+                color += vec4(texture(u_radianceTexture, L).rgb, 1.0) * NdotL;\n\
+                weight += NdotL;\n\
+            }\n\
+        }\n\
+    out_FragColor = color / weight;\n\
+}\n\
+";