@cesium/engine 11.0.0 → 12.0.0

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/DepthPlaneVS.glsl

@@ -5,7 +5,7 @@ out vec4 positionEC;
 void main()
 {
     positionEC = czm_modelView * position;
-    gl_Position = czm_projection * positionEC;
+    gl_Position = czm_modelViewProjection * position;
 
     czm_vertexLogDepth();
 }

package/Source/Shaders/DepthPlaneVS.js

@@ -6,7 +6,7 @@ out vec4 positionEC;\n\
 void main()\n\
 {\n\
     positionEC = czm_modelView * position;\n\
-    gl_Position = czm_projection * positionEC;\n\
+    gl_Position = czm_modelViewProjection * position;\n\
 \n\
     czm_vertexLogDepth();\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

package/Source/Shaders/Model/ImageBasedLightingStageFS.js

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

package/Source/Shaders/Model/LightingStageFS.glsl

@@ -5,14 +5,10 @@ vec3 computeIBL(vec3 position, vec3 normal, vec3 lightDirection, vec3 lightColor
         // Environment maps were provided, use them for IBL
         vec3 viewDirection = -normalize(position);
         vec3 iblColor = textureIBL(viewDirection, normal, material);
-    #else
-        // Use procedural IBL if there are no environment maps
-        vec3 imageBasedLighting = proceduralIBL(position, normal, lightDirection, material);
-        float maximumComponent = czm_maximumComponent(lightColorHdr);
-        vec3 clampedLightColor = lightColorHdr / max(maximumComponent, 1.0);
-        vec3 iblColor = clampedLightColor * imageBasedLighting;
+        return iblColor;
     #endif
-    return iblColor * material.occlusion;
+    
+    return vec3(0.0);
 }
 #endif
 
@@ -44,21 +40,6 @@ vec3 addClearcoatReflection(vec3 baseLayerColor, vec3 position, vec3 lightDirect
         vec3 reflectMC = normalize(model_iblReferenceFrameMatrix * reflect(-viewDirection, normal));
         vec3 iblColor = computeSpecularIBL(reflectMC, NdotV, f0, roughness);
         color += iblColor * material.occlusion;
-    #elif defined(USE_IBL_LIGHTING)
-        vec3 positionWC = vec3(czm_inverseView * vec4(position, 1.0));
-        vec3 reflectionWC = normalize(czm_inverseViewRotation * reflect(viewDirection, normal));
-        vec3 skyMetrics = getProceduralSkyMetrics(positionWC, reflectionWC);
-
-        vec3 specularIrradiance = getProceduralSpecularIrradiance(reflectionWC, skyMetrics, roughness);
-        vec2 brdfLut = texture(czm_brdfLut, vec2(NdotV, roughness)).rg;
-        vec3 specularColor = czm_srgbToLinear(f0 * brdfLut.x + brdfLut.y);
-        vec3 iblColor = specularIrradiance * specularColor * model_iblFactor.y;
-        #ifdef USE_SUN_LUMINANCE
-            iblColor *= getSunLuminance(positionWC, normal, lightDirection);
-        #endif
-        float maximumComponent = czm_maximumComponent(lightColorHdr);
-        vec3 clampedLightColor = lightColorHdr / max(maximumComponent, 1.0);
-        color += clampedLightColor * iblColor * material.occlusion;
     #endif
 
     float clearcoatFactor = material.clearcoatFactor;

package/Source/Shaders/Model/LightingStageFS.js

@@ -6,14 +6,10 @@ vec3 computeIBL(vec3 position, vec3 normal, vec3 lightDirection, vec3 lightColor
         // Environment maps were provided, use them for IBL\n\
         vec3 viewDirection = -normalize(position);\n\
         vec3 iblColor = textureIBL(viewDirection, normal, material);\n\
-    #else\n\
-        // Use procedural IBL if there are no environment maps\n\
-        vec3 imageBasedLighting = proceduralIBL(position, normal, lightDirection, material);\n\
-        float maximumComponent = czm_maximumComponent(lightColorHdr);\n\
-        vec3 clampedLightColor = lightColorHdr / max(maximumComponent, 1.0);\n\
-        vec3 iblColor = clampedLightColor * imageBasedLighting;\n\
+        return iblColor;\n\
     #endif\n\
-    return iblColor * material.occlusion;\n\
+    \n\
+    return vec3(0.0);\n\
 }\n\
 #endif\n\
 \n\
@@ -45,21 +41,6 @@ vec3 addClearcoatReflection(vec3 baseLayerColor, vec3 position, vec3 lightDirect
         vec3 reflectMC = normalize(model_iblReferenceFrameMatrix * reflect(-viewDirection, normal));\n\
         vec3 iblColor = computeSpecularIBL(reflectMC, NdotV, f0, roughness);\n\
         color += iblColor * material.occlusion;\n\
-    #elif defined(USE_IBL_LIGHTING)\n\
-        vec3 positionWC = vec3(czm_inverseView * vec4(position, 1.0));\n\
-        vec3 reflectionWC = normalize(czm_inverseViewRotation * reflect(viewDirection, normal));\n\
-        vec3 skyMetrics = getProceduralSkyMetrics(positionWC, reflectionWC);\n\
-\n\
-        vec3 specularIrradiance = getProceduralSpecularIrradiance(reflectionWC, skyMetrics, roughness);\n\
-        vec2 brdfLut = texture(czm_brdfLut, vec2(NdotV, roughness)).rg;\n\
-        vec3 specularColor = czm_srgbToLinear(f0 * brdfLut.x + brdfLut.y);\n\
-        vec3 iblColor = specularIrradiance * specularColor * model_iblFactor.y;\n\
-        #ifdef USE_SUN_LUMINANCE\n\
-            iblColor *= getSunLuminance(positionWC, normal, lightDirection);\n\
-        #endif\n\
-        float maximumComponent = czm_maximumComponent(lightColorHdr);\n\
-        vec3 clampedLightColor = lightColorHdr / max(maximumComponent, 1.0);\n\
-        color += clampedLightColor * iblColor * material.occlusion;\n\
     #endif\n\
 \n\
     float clearcoatFactor = material.clearcoatFactor;\n\

package/Source/Shaders/Model/ModelFS.glsl

@@ -45,6 +45,10 @@ void main()
     MetadataStatistics metadataStatistics;
     metadataStage(metadata, metadataClass, metadataStatistics, attributes);
 
+    //========================================================================
+    // When not picking metadata START
+    #ifndef METADATA_PICKING_ENABLED
+
     #ifdef HAS_SELECTED_FEATURE_ID
     selectedFeatureIdStage(selectedFeature, featureIds);
     #endif
@@ -73,6 +77,20 @@ void main()
 
     vec4 color = handleAlpha(material.diffuse, material.alpha);
 
+    // When not picking metadata END
+    //========================================================================
+    #else 
+    //========================================================================
+    // When picking metadata START
+
+    vec4 metadataValues = vec4(0.0, 0.0, 0.0, 0.0);
+    metadataPickingStage(metadata, metadataClass, metadataValues);
+    vec4 color = metadataValues;
+
+    #endif
+    // When picking metadata END
+    //========================================================================
+
     #ifdef HAS_CLIPPING_PLANES
     modelClippingPlanesStage(color);
     #endif
@@ -81,6 +99,10 @@ void main()
     modelClippingPolygonsStage();
     #endif
 
+    //========================================================================
+    // When not picking metadata START
+    #ifndef METADATA_PICKING_ENABLED
+
     #if defined(HAS_SILHOUETTE) && defined(HAS_NORMALS)
     silhouetteStage(color);
     #endif
@@ -89,5 +111,9 @@ void main()
     atmosphereStage(color, attributes);
     #endif
 
+    #endif
+    // When not picking metadata END
+    //========================================================================
+
     out_FragColor = color;
 }

package/Source/Shaders/Model/ModelFS.js

@@ -45,6 +45,10 @@ void main()\n\
     MetadataClass metadataClass;\n\
     MetadataStatistics metadataStatistics;\n\
     metadataStage(metadata, metadataClass, metadataStatistics, attributes);\n\
+\n\
+    //========================================================================\n\
+    // When not picking metadata START\n\
+    #ifndef METADATA_PICKING_ENABLED\n\
 \n\
     #ifdef HAS_SELECTED_FEATURE_ID\n\
     selectedFeatureIdStage(selectedFeature, featureIds);\n\
@@ -73,6 +77,20 @@ void main()\n\
     #endif\n\
 \n\
     vec4 color = handleAlpha(material.diffuse, material.alpha);\n\
+\n\
+    // When not picking metadata END\n\
+    //========================================================================\n\
+    #else \n\
+    //========================================================================\n\
+    // When picking metadata START\n\
+\n\
+    vec4 metadataValues = vec4(0.0, 0.0, 0.0, 0.0);\n\
+    metadataPickingStage(metadata, metadataClass, metadataValues);\n\
+    vec4 color = metadataValues;\n\
+\n\
+    #endif\n\
+    // When picking metadata END\n\
+    //========================================================================\n\
 \n\
     #ifdef HAS_CLIPPING_PLANES\n\
     modelClippingPlanesStage(color);\n\
@@ -81,6 +99,10 @@ void main()\n\
     #ifdef ENABLE_CLIPPING_POLYGONS\n\
     modelClippingPolygonsStage();\n\
     #endif\n\
+\n\
+    //========================================================================\n\
+    // When not picking metadata START\n\
+    #ifndef METADATA_PICKING_ENABLED\n\
 \n\
     #if defined(HAS_SILHOUETTE) && defined(HAS_NORMALS)\n\
     silhouetteStage(color);\n\
@@ -89,6 +111,10 @@ void main()\n\
     #ifdef HAS_ATMOSPHERE\n\
     atmosphereStage(color, attributes);\n\
     #endif\n\
+\n\
+    #endif\n\
+    // When not picking metadata END\n\
+    //========================================================================\n\
 \n\
     out_FragColor = color;\n\
 }\n\