@cesium/engine 11.1.0 → 12.0.1

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\
+";

package/Source/Shaders/ConvolveSpecularMapVS.glsl

@@ -0,0 +1,24 @@
+in vec3 position;
+out vec3 v_textureCoordinates;
+
+uniform vec3 u_faceDirection;
+
+vec3 getCubeMapDirection(vec2 uv, vec3 faceDir) {
+    vec2 scaledUV = uv;
+
+    if (faceDir.x != 0.0) {
+        return vec3(faceDir.x, scaledUV.y, scaledUV.x * faceDir.x);
+    } else if (faceDir.y != 0.0) {
+        return vec3(scaledUV.x, -faceDir.y, -scaledUV.y * faceDir.y);
+    } else {
+        return vec3(scaledUV.x * faceDir.z, scaledUV.y, -faceDir.z); 
+    }
+}
+
+void main() 
+{
+    v_textureCoordinates = getCubeMapDirection(position.xy, u_faceDirection);
+    v_textureCoordinates.y = -v_textureCoordinates.y;
+    v_textureCoordinates.z = -v_textureCoordinates.z;
+    gl_Position = vec4(position, 1.0);
+}

package/Source/Shaders/ConvolveSpecularMapVS.js

@@ -0,0 +1,26 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "in vec3 position;\n\
+out vec3 v_textureCoordinates;\n\
+\n\
+uniform vec3 u_faceDirection;\n\
+\n\
+vec3 getCubeMapDirection(vec2 uv, vec3 faceDir) {\n\
+    vec2 scaledUV = uv;\n\
+\n\
+    if (faceDir.x != 0.0) {\n\
+        return vec3(faceDir.x, scaledUV.y, scaledUV.x * faceDir.x);\n\
+    } else if (faceDir.y != 0.0) {\n\
+        return vec3(scaledUV.x, -faceDir.y, -scaledUV.y * faceDir.y);\n\
+    } else {\n\
+        return vec3(scaledUV.x * faceDir.z, scaledUV.y, -faceDir.z); \n\
+    }\n\
+}\n\
+\n\
+void main() \n\
+{\n\
+    v_textureCoordinates = getCubeMapDirection(position.xy, u_faceDirection);\n\
+    v_textureCoordinates.y = -v_textureCoordinates.y;\n\
+    v_textureCoordinates.z = -v_textureCoordinates.z;\n\
+    gl_Position = vec4(position, 1.0);\n\
+}\n\
+";

package/Source/Shaders/GlobeFS.glsl

@@ -499,8 +499,7 @@ void main()
                 fogColor.rgb = czm_inverseGamma(fogColor.rgb);
             #endif
 
-            const float modifier = 0.15;
-            finalColor = vec4(czm_fog(v_distance, finalColor.rgb, fogColor.rgb, modifier), finalColor.a);
+            finalColor = vec4(czm_fog(v_distance, finalColor.rgb, fogColor.rgb, czm_fogVisualDensityScalar), finalColor.a);
 
         #else
             // Apply ground atmosphere. This happens when the camera is far away from the earth.

package/Source/Shaders/GlobeFS.js

@@ -500,8 +500,7 @@ void main()\n\
                 fogColor.rgb = czm_inverseGamma(fogColor.rgb);\n\
             #endif\n\
 \n\
-            const float modifier = 0.15;\n\
-            finalColor = vec4(czm_fog(v_distance, finalColor.rgb, fogColor.rgb, modifier), finalColor.a);\n\
+            finalColor = vec4(czm_fog(v_distance, finalColor.rgb, fogColor.rgb, czm_fogVisualDensityScalar), finalColor.a);\n\
 \n\
         #else\n\
             // Apply ground atmosphere. This happens when the camera is far away from the earth.\n\

package/Source/Shaders/Model/AtmosphereStageFS.glsl

@@ -56,10 +56,7 @@ void applyFog(inout vec4 color, vec4 groundAtmosphereColor, vec3 lightDirection,
         fogColor.rgb = czm_inverseGamma(fogColor.rgb);
     #endif
 
-    // Matches the constant in GlobeFS.glsl. This makes the fog falloff
-    // more gradual.
-    const float fogModifier = 0.15;
-    vec3 withFog = czm_fog(distanceToCamera, color.rgb, fogColor, fogModifier);
+    vec3 withFog = czm_fog(distanceToCamera, color.rgb, fogColor, czm_fogVisualDensityScalar);
     color = vec4(withFog, color.a);
 }
 

package/Source/Shaders/Model/AtmosphereStageFS.js

@@ -57,10 +57,7 @@ void applyFog(inout vec4 color, vec4 groundAtmosphereColor, vec3 lightDirection,
         fogColor.rgb = czm_inverseGamma(fogColor.rgb);\n\
     #endif\n\
 \n\
-    // Matches the constant in GlobeFS.glsl. This makes the fog falloff\n\
-    // more gradual.\n\
-    const float fogModifier = 0.15;\n\
-    vec3 withFog = czm_fog(distanceToCamera, color.rgb, fogColor, fogModifier);\n\
+    vec3 withFog = czm_fog(distanceToCamera, color.rgb, fogColor, czm_fogVisualDensityScalar);\n\
     color = vec4(withFog, color.a);\n\
 }\n\
 \n\

package/Source/Shaders/Model/ImageBasedLightingStageFS.glsl

@@ -1,156 +1,3 @@
-/**
- * Compute some metrics for a procedural sky lighting model
- *
- * @param {vec3} positionWC The position of the fragment in world coordinates.
- * @param {vec3} reflectionWC A unit vector in the direction of the reflection, in world coordinates.
- * @return {vec3} The dot products of the horizon and reflection directions with the nadir, and an atmosphere boundary distance.
- */
-vec3 getProceduralSkyMetrics(vec3 positionWC, vec3 reflectionWC)
-{
-    // Figure out if the reflection vector hits the ellipsoid
-    float horizonDotNadir = 1.0 - min(1.0, czm_ellipsoidRadii.x / length(positionWC));
-    float reflectionDotNadir = dot(reflectionWC, normalize(positionWC));
-    float atmosphereHeight = 0.05;
-    float smoothstepHeight = smoothstep(0.0, atmosphereHeight, horizonDotNadir);
-    return vec3(horizonDotNadir, reflectionDotNadir, smoothstepHeight);
-}
-
-/**
- * Compute the diffuse irradiance for a procedural sky lighting model.
- *
- * @param {vec3} skyMetrics The dot products of the horizon and reflection directions with the nadir, and an atmosphere boundary distance.
- * @return {vec3} The computed diffuse irradiance.
- */
-vec3 getProceduralDiffuseIrradiance(vec3 skyMetrics)
-{
-    vec3 blueSkyDiffuseColor = vec3(0.7, 0.85, 0.9); 
-    float diffuseIrradianceFromEarth = (1.0 - skyMetrics.x) * (skyMetrics.y * 0.25 + 0.75) * skyMetrics.z;  
-    float diffuseIrradianceFromSky = (1.0 - skyMetrics.z) * (1.0 - (skyMetrics.y * 0.25 + 0.25));
-    return blueSkyDiffuseColor * clamp(diffuseIrradianceFromEarth + diffuseIrradianceFromSky, 0.0, 1.0);
-}
-
-/**
- * Compute the specular irradiance for a procedural sky lighting model.
- *
- * @param {vec3} reflectionWC The reflection vector in world coordinates.
- * @param {vec3} skyMetrics The dot products of the horizon and reflection directions with the nadir, and an atmosphere boundary distance.
- * @param {float} roughness The roughness of the material.
- * @return {vec3} The computed specular irradiance.
- */
-vec3 getProceduralSpecularIrradiance(vec3 reflectionWC, vec3 skyMetrics, float roughness)
-{
-    // Flipping the X vector is a cheap way to get the inverse of czm_temeToPseudoFixed, since that's a rotation about Z.
-    reflectionWC.x = -reflectionWC.x;
-    reflectionWC = -normalize(czm_temeToPseudoFixed * reflectionWC);
-    reflectionWC.x = -reflectionWC.x;
-
-    float inverseRoughness = 1.0 - roughness;
-    inverseRoughness *= inverseRoughness;
-    vec3 sceneSkyBox = czm_textureCube(czm_environmentMap, reflectionWC).rgb * inverseRoughness;
-
-    // Compute colors at different angles relative to the horizon
-    vec3 belowHorizonColor = mix(vec3(0.1, 0.15, 0.25), vec3(0.4, 0.7, 0.9), skyMetrics.z);
-    vec3 nadirColor = belowHorizonColor * 0.5;
-    vec3 aboveHorizonColor = mix(vec3(0.9, 1.0, 1.2), belowHorizonColor, roughness * 0.5);
-    vec3 blueSkyColor = mix(vec3(0.18, 0.26, 0.48), aboveHorizonColor, skyMetrics.y * inverseRoughness * 0.5 + 0.75);
-    vec3 zenithColor = mix(blueSkyColor, sceneSkyBox, skyMetrics.z);
-
-    // Compute blend zones
-    float blendRegionSize = 0.1 * ((1.0 - inverseRoughness) * 8.0 + 1.1 - skyMetrics.x);
-    float blendRegionOffset = roughness * -1.0;
-    float farAboveHorizon = clamp(skyMetrics.x - blendRegionSize * 0.5 + blendRegionOffset, 1.0e-10 - blendRegionSize, 0.99999);
-    float aroundHorizon = clamp(skyMetrics.x + blendRegionSize * 0.5, 1.0e-10 - blendRegionSize, 0.99999);
-    float farBelowHorizon = clamp(skyMetrics.x + blendRegionSize * 1.5, 1.0e-10 - blendRegionSize, 0.99999);
-
-    // Blend colors
-    float notDistantRough = (1.0 - skyMetrics.x * roughness * 0.8);
-    vec3 specularIrradiance = mix(zenithColor, aboveHorizonColor, smoothstep(farAboveHorizon, aroundHorizon, skyMetrics.y) * notDistantRough);
-    specularIrradiance = mix(specularIrradiance, belowHorizonColor, smoothstep(aroundHorizon, farBelowHorizon, skyMetrics.y) * inverseRoughness);
-    specularIrradiance = mix(specularIrradiance, nadirColor, smoothstep(farBelowHorizon, 1.0, skyMetrics.y) * inverseRoughness);
-
-    return specularIrradiance;
-}
-
-#ifdef USE_SUN_LUMINANCE
-float clampedDot(vec3 x, vec3 y)
-{
-    return clamp(dot(x, y), 0.001, 1.0);
-}
-/**
- * Sun luminance following the "CIE Clear Sky Model"
- * See page 40 of https://3dvar.com/Green2003Spherical.pdf
- *
- * @param {vec3} positionWC The position of the fragment in world coordinates.
- * @param {vec3} normalEC The surface normal in eye coordinates.
- * @param {vec3} lightDirectionEC Unit vector pointing to the light source in eye coordinates.
- * @return {float} The computed sun luminance.
- */
-float getSunLuminance(vec3 positionWC, vec3 normalEC, vec3 lightDirectionEC)
-{
-    vec3 normalWC = normalize(czm_inverseViewRotation * normalEC);
-    vec3 lightDirectionWC = normalize(czm_inverseViewRotation * lightDirectionEC);
-    vec3 vWC = -normalize(positionWC);
-
-    // Angle between sun and zenith.
-    float LdotZenith = clampedDot(lightDirectionWC, vWC);
-    float S = acos(LdotZenith);
-    // Angle between zenith and current pixel
-    float NdotZenith = clampedDot(normalWC, vWC);
-    // Angle between sun and current pixel
-    float NdotL = clampedDot(normalEC, lightDirectionEC);
-    float gamma = acos(NdotL);
-
-    float numerator = ((0.91 + 10.0 * exp(-3.0 * gamma) + 0.45 * NdotL * NdotL) * (1.0 - exp(-0.32 / NdotZenith)));
-    float denominator = (0.91 + 10.0 * exp(-3.0 * S) + 0.45 * LdotZenith * LdotZenith) * (1.0 - exp(-0.32));
-    return model_luminanceAtZenith * (numerator / denominator);
-}
-#endif
-
-/**
- * Compute the light contribution from a procedural sky model
- *
- * @param {vec3} positionEC The position of the fragment in eye coordinates.
- * @param {vec3} normalEC The surface normal in eye coordinates.
- * @param {vec3} lightDirectionEC Unit vector pointing to the light source in eye coordinates.
- * @param {czm_modelMaterial} The material properties.
- * @return {vec3} The computed HDR color
- */
- vec3 proceduralIBL(
-    vec3 positionEC,
-    vec3 normalEC,
-    vec3 lightDirectionEC,
-    czm_modelMaterial material
-) {
-    vec3 viewDirectionEC = -normalize(positionEC);
-    vec3 positionWC = vec3(czm_inverseView * vec4(positionEC, 1.0));
-    vec3 reflectionWC = normalize(czm_inverseViewRotation * reflect(viewDirectionEC, normalEC));
-    vec3 skyMetrics = getProceduralSkyMetrics(positionWC, reflectionWC);
-
-    float roughness = material.roughness;
-    vec3 f0 = material.specular;
-
-    vec3 specularIrradiance = getProceduralSpecularIrradiance(reflectionWC, skyMetrics, roughness);
-    float NdotV = abs(dot(normalEC, viewDirectionEC)) + 0.001;
-    vec2 brdfLut = texture(czm_brdfLut, vec2(NdotV, roughness)).rg;
-    vec3 specularColor = czm_srgbToLinear(f0 * brdfLut.x + brdfLut.y);
-    vec3 specularContribution = specularIrradiance * specularColor * model_iblFactor.y;
-    #ifdef USE_SPECULAR
-        specularContribution *= material.specularWeight;
-    #endif
-
-    vec3 diffuseIrradiance = getProceduralDiffuseIrradiance(skyMetrics);
-    vec3 diffuseColor = material.diffuse;
-    vec3 diffuseContribution = diffuseIrradiance * diffuseColor * model_iblFactor.x;
-
-    vec3 iblColor = specularContribution + diffuseContribution;
-
-    #ifdef USE_SUN_LUMINANCE
-        iblColor *= getSunLuminance(positionWC, normalEC, lightDirectionEC);
-    #endif
-
-    return iblColor;
-}
-
 #ifdef DIFFUSE_IBL
 vec3 sampleDiffuseEnvironment(vec3 cubeDir)
 {
@@ -223,7 +70,7 @@ vec3 textureIBL(vec3 viewDirectionEC, vec3 normalEC, czm_modelMaterial material)
         float Ems = specularWeight * (1.0 - brdfLut.x - brdfLut.y);
         vec3 FmsEms = FssEss * averageFresnel * Ems / (1.0 - averageFresnel * Ems);
         vec3 dielectricScattering = (1.0 - FssEss - FmsEms) * material.diffuse;
-        vec3 diffuseContribution = irradiance * (FmsEms + dielectricScattering);
+        vec3 diffuseContribution = irradiance * (FmsEms + dielectricScattering) * model_iblFactor.x;
     #else
         vec3 diffuseContribution = vec3(0.0);
     #endif
@@ -244,7 +91,7 @@ vec3 textureIBL(vec3 viewDirectionEC, vec3 normalEC, czm_modelMaterial material)
     #ifdef SPECULAR_IBL
         vec3 reflectMC = normalize(model_iblReferenceFrameMatrix * reflectEC);
         vec3 radiance = sampleSpecularEnvironment(reflectMC, roughness);
-        vec3 specularContribution = radiance * FssEss;
+        vec3 specularContribution = radiance * FssEss * model_iblFactor.y;
     #else
         vec3 specularContribution = vec3(0.0);
     #endif