@cesium/engine 10.1.0 → 11.1.0

package/Source/Shaders/Model/ImageBasedLightingStageFS.js

@@ -153,7 +153,7 @@ float getSunLuminance(vec3 positionWC, vec3 normalEC, vec3 lightDirectionEC)\n\
 }\n\
 \n\
 #ifdef DIFFUSE_IBL\n\
-vec3 computeDiffuseIBL(vec3 cubeDir)\n\
+vec3 sampleDiffuseEnvironment(vec3 cubeDir)\n\
 {\n\
     #ifdef CUSTOM_SPHERICAL_HARMONICS\n\
         return czm_sphericalHarmonics(cubeDir, model_sphericalHarmonicCoefficients); \n\
@@ -167,13 +167,11 @@ vec3 computeDiffuseIBL(vec3 cubeDir)\n\
 vec3 sampleSpecularEnvironment(vec3 cubeDir, float roughness)\n\
 {\n\
     #ifdef CUSTOM_SPECULAR_IBL\n\
-        float maxLod = model_specularEnvironmentMapsMaximumLOD;\n\
-        float lod = roughness * maxLod;\n\
-        return czm_sampleOctahedralProjection(model_specularEnvironmentMaps, model_specularEnvironmentMapsSize, cubeDir, lod, maxLod);\n\
+        float lod = roughness * model_specularEnvironmentMapsMaximumLOD;\n\
+        return czm_textureCube(model_specularEnvironmentMaps, cubeDir, lod).rgb;\n\
     #else\n\
-        float maxLod = czm_specularEnvironmentMapsMaximumLOD;\n\
-        float lod = roughness * maxLod;\n\
-        return czm_sampleOctahedralProjection(czm_specularEnvironmentMaps, czm_specularEnvironmentMapSize, cubeDir, lod, maxLod);\n\
+        float lod = roughness * czm_specularEnvironmentMapsMaximumLOD;\n\
+        return czm_textureCube(czm_specularEnvironmentMaps, cubeDir, lod).rgb;\n\
     #endif\n\
 }\n\
 vec3 computeSpecularIBL(vec3 cubeDir, float NdotV, vec3 f0, float roughness)\n\
@@ -192,25 +190,43 @@ vec3 computeSpecularIBL(vec3 cubeDir, float NdotV, vec3 f0, float roughness)\n\
 \n\
 #if defined(DIFFUSE_IBL) || defined(SPECULAR_IBL)\n\
 /**\n\
- * Compute the light contributions from environment maps and spherical harmonic coefficients\n\
+ * Compute the light contributions from environment maps and spherical harmonic coefficients.\n\
+ * See Fdez-Aguera, https://www.jcgt.org/published/0008/01/03/paper.pdf, for explanation\n\
+ * of the single- and multi-scattering terms.\n\
  *\n\
- * @param {vec3} viewDirectionEC Unit vector pointing from the fragment to the eye position\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 {vec3} viewDirectionEC Unit vector pointing from the fragment to the eye position.\n\
+ * @param {vec3} normalEC The surface normal in eye coordinates.\n\
  * @param {czm_modelMaterial} The material properties.\n\
- * @return {vec3} The computed HDR color\n\
+ * @return {vec3} The computed HDR color.\n\
  */\n\
-vec3 textureIBL(\n\
-    vec3 viewDirectionEC,\n\
-    vec3 normalEC,\n\
-    vec3 lightDirectionEC,\n\
-    czm_modelMaterial material\n\
-) {\n\
+vec3 textureIBL(vec3 viewDirectionEC, vec3 normalEC, czm_modelMaterial material) {\n\
+    vec3 f0 = material.specular;\n\
+    float roughness = material.roughness;\n\
+    float specularWeight = 1.0;\n\
+    #ifdef USE_SPECULAR\n\
+        specularWeight = material.specularWeight;\n\
+    #endif\n\
+    float NdotV = clamp(dot(normalEC, viewDirectionEC), 0.0, 1.0);\n\
+\n\
+    // see https://bruop.github.io/ibl/ at Single Scattering Results\n\
+    // Roughness dependent fresnel, from Fdez-Aguera\n\
+    vec3 f90 = max(vec3(1.0 - roughness), f0);\n\
+    vec3 singleScatterFresnel = fresnelSchlick2(f0, f90, NdotV);\n\
+\n\
+    vec2 brdfLut = texture(czm_brdfLut, vec2(NdotV, roughness)).rg;\n\
+    vec3 FssEss = specularWeight * (singleScatterFresnel * brdfLut.x + brdfLut.y);\n\
+\n\
     #ifdef DIFFUSE_IBL\n\
         vec3 normalMC = normalize(model_iblReferenceFrameMatrix * normalEC);\n\
-        vec3 diffuseContribution = computeDiffuseIBL(normalMC) * material.diffuse;\n\
+        vec3 irradiance = sampleDiffuseEnvironment(normalMC);\n\
+\n\
+        vec3 averageFresnel = f0 + (1.0 - f0) / 21.0;\n\
+        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\
     #else\n\
-        vec3 diffuseContribution = vec3(0.0); \n\
+        vec3 diffuseContribution = vec3(0.0);\n\
     #endif\n\
 \n\
     #ifdef USE_ANISOTROPY\n\
@@ -218,7 +234,7 @@ vec3 textureIBL(\n\
         vec3 anisotropyDirection = material.anisotropicB;\n\
         vec3 anisotropicTangent = cross(anisotropyDirection, viewDirectionEC);\n\
         vec3 anisotropicNormal = cross(anisotropicTangent, anisotropyDirection);\n\
-        float bendFactor = 1.0 - material.anisotropyStrength * (1.0 - material.roughness);\n\
+        float bendFactor = 1.0 - material.anisotropyStrength * (1.0 - roughness);\n\
         float bendFactorPow4 = bendFactor * bendFactor * bendFactor * bendFactor;\n\
         vec3 bentNormal = normalize(mix(anisotropicNormal, normalEC, bendFactorPow4));\n\
         vec3 reflectEC = reflect(-viewDirectionEC, bentNormal);\n\
@@ -228,15 +244,10 @@ vec3 textureIBL(\n\
 \n\
     #ifdef SPECULAR_IBL\n\
         vec3 reflectMC = normalize(model_iblReferenceFrameMatrix * reflectEC);\n\
-        float NdotV = clamp(dot(normalEC, viewDirectionEC), 0.0, 1.0);\n\
-        vec3 f0 = material.specular;\n\
-        vec3 specularContribution = computeSpecularIBL(reflectMC, NdotV, f0, material.roughness);\n\
+        vec3 radiance = sampleSpecularEnvironment(reflectMC, roughness);\n\
+        vec3 specularContribution = radiance * FssEss;\n\
     #else\n\
-        vec3 specularContribution = vec3(0.0); \n\
-    #endif\n\
-\n\
-    #ifdef USE_SPECULAR\n\
-        specularContribution *= material.specularWeight;\n\
+        vec3 specularContribution = vec3(0.0);\n\
     #endif\n\
 \n\
     return diffuseContribution + specularContribution;\n\

package/Source/Shaders/Model/LightingStageFS.glsl

@@ -4,7 +4,7 @@ vec3 computeIBL(vec3 position, vec3 normal, vec3 lightDirection, vec3 lightColor
     #if defined(DIFFUSE_IBL) || defined(SPECULAR_IBL)
         // Environment maps were provided, use them for IBL
         vec3 viewDirection = -normalize(position);
-        vec3 iblColor = textureIBL(viewDirection, normal, lightDirection, material);
+        vec3 iblColor = textureIBL(viewDirection, normal, material);
     #else
         // Use procedural IBL if there are no environment maps
         vec3 imageBasedLighting = proceduralIBL(position, normal, lightDirection, material);
@@ -120,7 +120,7 @@ void lightingStage(inout czm_modelMaterial material, ProcessedAttributes attribu
         // tonemapping. However, if HDR is not enabled, we must tonemap else large
         // values may be clamped to 1.0
         #ifndef HDR
-            color = czm_acesTonemapping(color);
+            color = czm_pbrNeutralTonemapping(color);
         #endif
     #else // unlit
         vec3 color = material.diffuse;

package/Source/Shaders/Model/LightingStageFS.js

@@ -5,7 +5,7 @@ vec3 computeIBL(vec3 position, vec3 normal, vec3 lightDirection, vec3 lightColor
     #if defined(DIFFUSE_IBL) || defined(SPECULAR_IBL)\n\
         // Environment maps were provided, use them for IBL\n\
         vec3 viewDirection = -normalize(position);\n\
-        vec3 iblColor = textureIBL(viewDirection, normal, lightDirection, material);\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\
@@ -121,7 +121,7 @@ void lightingStage(inout czm_modelMaterial material, ProcessedAttributes attribu
         // tonemapping. However, if HDR is not enabled, we must tonemap else large\n\
         // values may be clamped to 1.0\n\
         #ifndef HDR\n\
-            color = czm_acesTonemapping(color);\n\
+            color = czm_pbrNeutralTonemapping(color);\n\
         #endif\n\
     #else // unlit\n\
         vec3 color = material.diffuse;\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\

package/Source/Shaders/PostProcessStages/AcesTonemappingStage.glsl

@@ -4,6 +4,8 @@ in vec2 v_textureCoordinates;
 
 #ifdef AUTO_EXPOSURE
 uniform sampler2D autoExposure;
+#else
+uniform float exposure;
 #endif
 
 void main()
@@ -13,6 +15,8 @@ void main()
 
 #ifdef AUTO_EXPOSURE
     color /= texture(autoExposure, vec2(0.5)).r;
+#else
+    color *= vec3(exposure);
 #endif
     color = czm_acesTonemapping(color);
     color = czm_inverseGamma(color);

package/Source/Shaders/PostProcessStages/AcesTonemappingStage.js

@@ -5,6 +5,8 @@ in vec2 v_textureCoordinates;\n\
 \n\
 #ifdef AUTO_EXPOSURE\n\
 uniform sampler2D autoExposure;\n\
+#else\n\
+uniform float exposure;\n\
 #endif\n\
 \n\
 void main()\n\
@@ -14,6 +16,8 @@ void main()\n\
 \n\
 #ifdef AUTO_EXPOSURE\n\
     color /= texture(autoExposure, vec2(0.5)).r;\n\
+#else\n\
+    color *= vec3(exposure);\n\
 #endif\n\
     color = czm_acesTonemapping(color);\n\
     color = czm_inverseGamma(color);\n\

package/Source/Shaders/PostProcessStages/AmbientOcclusionGenerate.glsl

@@ -1,3 +1,5 @@
+precision highp float;
+
 uniform sampler2D randomTexture;
 uniform sampler2D depthTexture;
 uniform float intensity;
@@ -6,109 +8,107 @@ uniform float lengthCap;
 uniform float stepSize;
 uniform float frustumLength;
 
-in vec2 v_textureCoordinates;
-
-vec4 clipToEye(vec2 uv, float depth)
+vec3 pixelToEye(vec2 screenCoordinate)
 {
-    vec2 xy = vec2((uv.x * 2.0 - 1.0), ((1.0 - uv.y) * 2.0 - 1.0));
+    vec2 uv = screenCoordinate / czm_viewport.zw;
+    float depth = czm_readDepth(depthTexture, uv);
+    vec2 xy = 2.0 * uv - vec2(1.0);
     vec4 posEC = czm_inverseProjection * vec4(xy, depth, 1.0);
-    posEC = posEC / posEC.w;
-    return posEC;
+    return posEC.xyz / posEC.w;
 }
 
-//Reconstruct Normal Without Edge Removation
-vec3 getNormalXEdge(vec3 posInCamera, float depthU, float depthD, float depthL, float depthR, vec2 pixelSize)
+// Reconstruct surface normal in eye coordinates, avoiding edges
+vec3 getNormalXEdge(vec3 positionEC)
 {
-    vec4 posInCameraUp = clipToEye(v_textureCoordinates - vec2(0.0, pixelSize.y), depthU);
-    vec4 posInCameraDown = clipToEye(v_textureCoordinates + vec2(0.0, pixelSize.y), depthD);
-    vec4 posInCameraLeft = clipToEye(v_textureCoordinates - vec2(pixelSize.x, 0.0), depthL);
-    vec4 posInCameraRight = clipToEye(v_textureCoordinates + vec2(pixelSize.x, 0.0), depthR);
-
-    vec3 up = posInCamera.xyz - posInCameraUp.xyz;
-    vec3 down = posInCameraDown.xyz - posInCamera.xyz;
-    vec3 left = posInCamera.xyz - posInCameraLeft.xyz;
-    vec3 right = posInCameraRight.xyz - posInCamera.xyz;
-
-    vec3 DX = length(left) < length(right) ? left : right;
-    vec3 DY = length(up) < length(down) ? up : down;
-
-    return normalize(cross(DY, DX));
+    // Find the 3D surface positions at adjacent screen pixels
+    vec2 centerCoord = gl_FragCoord.xy;
+    vec3 positionLeft = pixelToEye(centerCoord + vec2(-1.0, 0.0));
+    vec3 positionRight = pixelToEye(centerCoord + vec2(1.0, 0.0));
+    vec3 positionUp = pixelToEye(centerCoord + vec2(0.0, 1.0));
+    vec3 positionDown = pixelToEye(centerCoord + vec2(0.0, -1.0));
+
+    // Compute potential tangent vectors
+    vec3 dx0 = positionEC - positionLeft;
+    vec3 dx1 = positionRight - positionEC;
+    vec3 dy0 = positionEC - positionDown;
+    vec3 dy1 = positionUp - positionEC;
+
+    // The shorter tangent is more likely to be on the same surface
+    vec3 dx = length(dx0) < length(dx1) ? dx0 : dx1;
+    vec3 dy = length(dy0) < length(dy1) ? dy0 : dy1;
+
+    return normalize(cross(dx, dy));
 }
 
 void main(void)
 {
-    float depth = czm_readDepth(depthTexture, v_textureCoordinates);
-    vec4 posInCamera = clipToEye(v_textureCoordinates, depth);
+    vec3 positionEC = pixelToEye(gl_FragCoord.xy);
 
-    if (posInCamera.z > frustumLength)
+    if (positionEC.z > frustumLength)
     {
         out_FragColor = vec4(1.0);
         return;
     }
 
-    vec2 pixelSize = czm_pixelRatio / czm_viewport.zw;
-    float depthU = czm_readDepth(depthTexture, v_textureCoordinates - vec2(0.0, pixelSize.y));
-    float depthD = czm_readDepth(depthTexture, v_textureCoordinates + vec2(0.0, pixelSize.y));
-    float depthL = czm_readDepth(depthTexture, v_textureCoordinates - vec2(pixelSize.x, 0.0));
-    float depthR = czm_readDepth(depthTexture, v_textureCoordinates + vec2(pixelSize.x, 0.0));
-    vec3 normalInCamera = getNormalXEdge(posInCamera.xyz, depthU, depthD, depthL, depthR, pixelSize);
+    vec3 normalEC = getNormalXEdge(positionEC);
 
     float ao = 0.0;
-    vec2 sampleDirection = vec2(1.0, 0.0);
-    float gapAngle = 90.0 * czm_radiansPerDegree;
 
-    // RandomNoise
-    float randomVal = texture(randomTexture, v_textureCoordinates / pixelSize / 255.0).x;
-
-    //Loop for each direction
-    for (int i = 0; i < 4; i++)
+    const int ANGLE_STEPS = 4;
+    float angleStepScale = 1.0 / float(ANGLE_STEPS);
+    float angleStep = angleStepScale * czm_twoPi;
+    float cosStep = cos(angleStep);
+    float sinStep = sin(angleStep);
+    mat2 rotateStep = mat2(cosStep, sinStep, -sinStep, cosStep);
+
+    // Initial sampling direction (different for each pixel)
+    const float randomTextureSize = 255.0;
+    vec2 randomTexCoord = fract(gl_FragCoord.xy / randomTextureSize);
+    float randomVal = texture(randomTexture, randomTexCoord).x;
+    vec2 sampleDirection = vec2(cos(angleStep * randomVal), sin(angleStep * randomVal));
+
+    // Loop over sampling directions
+    for (int i = 0; i < ANGLE_STEPS; i++)
     {
-        float newGapAngle = gapAngle * (float(i) + randomVal);
-        float cosVal = cos(newGapAngle);
-        float sinVal = sin(newGapAngle);
+        sampleDirection = rotateStep * sampleDirection;
 
-        //Rotate Sampling Direction
-        vec2 rotatedSampleDirection = vec2(cosVal * sampleDirection.x - sinVal * sampleDirection.y, sinVal * sampleDirection.x + cosVal * sampleDirection.y);
         float localAO = 0.0;
-        float localStepSize = stepSize;
+        vec2 radialStep = stepSize * sampleDirection;
 
-        //Loop for each step
         for (int j = 0; j < 6; j++)
         {
-            vec2 newCoords = v_textureCoordinates + rotatedSampleDirection * localStepSize * pixelSize;
+            // Step along sampling direction, away from output pixel
+            vec2 newCoords = floor(gl_FragCoord.xy + float(j + 1) * radialStep) + vec2(0.5);
 
-            //Exception Handling
-            if(newCoords.x > 1.0 || newCoords.y > 1.0 || newCoords.x < 0.0 || newCoords.y < 0.0)
+            // Exit if we stepped off the screen
+            if (clamp(newCoords, vec2(0.0), czm_viewport.zw) != newCoords)
             {
                 break;
             }
 
-            float stepDepthInfo = czm_readDepth(depthTexture, newCoords);
-            vec4 stepPosInCamera = clipToEye(newCoords, stepDepthInfo);
-            vec3 diffVec = stepPosInCamera.xyz - posInCamera.xyz;
-            float len = length(diffVec);
+            vec3 stepPositionEC = pixelToEye(newCoords);
+            vec3 stepVector = stepPositionEC - positionEC;
+            float stepLength = length(stepVector);
 
-            if (len > lengthCap)
+            if (stepLength > lengthCap)
             {
                 break;
             }
 
-            float dotVal = clamp(dot(normalInCamera, normalize(diffVec)), 0.0, 1.0 );
-            float weight = len / lengthCap;
-            weight = 1.0 - weight * weight;
-
+            float dotVal = clamp(dot(normalEC, normalize(stepVector)), 0.0, 1.0);
             if (dotVal < bias)
             {
                 dotVal = 0.0;
             }
 
+            float weight = stepLength / lengthCap;
+            weight = 1.0 - weight * weight;
             localAO = max(localAO, dotVal * weight);
-            localStepSize += stepSize;
         }
         ao += localAO;
     }
 
-    ao /= 4.0;
+    ao *= angleStepScale;
     ao = 1.0 - clamp(ao, 0.0, 1.0);
     ao = pow(ao, intensity);
     out_FragColor = vec4(vec3(ao), 1.0);

package/Source/Shaders/PostProcessStages/AmbientOcclusionGenerate.js

@@ -1,5 +1,7 @@
 //This file is automatically rebuilt by the Cesium build process.
-export default "uniform sampler2D randomTexture;\n\
+export default "precision highp float;\n\
+\n\
+uniform sampler2D randomTexture;\n\
 uniform sampler2D depthTexture;\n\
 uniform float intensity;\n\
 uniform float bias;\n\
@@ -7,109 +9,107 @@ uniform float lengthCap;\n\
 uniform float stepSize;\n\
 uniform float frustumLength;\n\
 \n\
-in vec2 v_textureCoordinates;\n\
-\n\
-vec4 clipToEye(vec2 uv, float depth)\n\
+vec3 pixelToEye(vec2 screenCoordinate)\n\
 {\n\
-    vec2 xy = vec2((uv.x * 2.0 - 1.0), ((1.0 - uv.y) * 2.0 - 1.0));\n\
+    vec2 uv = screenCoordinate / czm_viewport.zw;\n\
+    float depth = czm_readDepth(depthTexture, uv);\n\
+    vec2 xy = 2.0 * uv - vec2(1.0);\n\
     vec4 posEC = czm_inverseProjection * vec4(xy, depth, 1.0);\n\
-    posEC = posEC / posEC.w;\n\
-    return posEC;\n\
+    return posEC.xyz / posEC.w;\n\
 }\n\
 \n\
-//Reconstruct Normal Without Edge Removation\n\
-vec3 getNormalXEdge(vec3 posInCamera, float depthU, float depthD, float depthL, float depthR, vec2 pixelSize)\n\
+// Reconstruct surface normal in eye coordinates, avoiding edges\n\
+vec3 getNormalXEdge(vec3 positionEC)\n\
 {\n\
-    vec4 posInCameraUp = clipToEye(v_textureCoordinates - vec2(0.0, pixelSize.y), depthU);\n\
-    vec4 posInCameraDown = clipToEye(v_textureCoordinates + vec2(0.0, pixelSize.y), depthD);\n\
-    vec4 posInCameraLeft = clipToEye(v_textureCoordinates - vec2(pixelSize.x, 0.0), depthL);\n\
-    vec4 posInCameraRight = clipToEye(v_textureCoordinates + vec2(pixelSize.x, 0.0), depthR);\n\
-\n\
-    vec3 up = posInCamera.xyz - posInCameraUp.xyz;\n\
-    vec3 down = posInCameraDown.xyz - posInCamera.xyz;\n\
-    vec3 left = posInCamera.xyz - posInCameraLeft.xyz;\n\
-    vec3 right = posInCameraRight.xyz - posInCamera.xyz;\n\
-\n\
-    vec3 DX = length(left) < length(right) ? left : right;\n\
-    vec3 DY = length(up) < length(down) ? up : down;\n\
-\n\
-    return normalize(cross(DY, DX));\n\
+    // Find the 3D surface positions at adjacent screen pixels\n\
+    vec2 centerCoord = gl_FragCoord.xy;\n\
+    vec3 positionLeft = pixelToEye(centerCoord + vec2(-1.0, 0.0));\n\
+    vec3 positionRight = pixelToEye(centerCoord + vec2(1.0, 0.0));\n\
+    vec3 positionUp = pixelToEye(centerCoord + vec2(0.0, 1.0));\n\
+    vec3 positionDown = pixelToEye(centerCoord + vec2(0.0, -1.0));\n\
+\n\
+    // Compute potential tangent vectors\n\
+    vec3 dx0 = positionEC - positionLeft;\n\
+    vec3 dx1 = positionRight - positionEC;\n\
+    vec3 dy0 = positionEC - positionDown;\n\
+    vec3 dy1 = positionUp - positionEC;\n\
+\n\
+    // The shorter tangent is more likely to be on the same surface\n\
+    vec3 dx = length(dx0) < length(dx1) ? dx0 : dx1;\n\
+    vec3 dy = length(dy0) < length(dy1) ? dy0 : dy1;\n\
+\n\
+    return normalize(cross(dx, dy));\n\
 }\n\
 \n\
 void main(void)\n\
 {\n\
-    float depth = czm_readDepth(depthTexture, v_textureCoordinates);\n\
-    vec4 posInCamera = clipToEye(v_textureCoordinates, depth);\n\
+    vec3 positionEC = pixelToEye(gl_FragCoord.xy);\n\
 \n\
-    if (posInCamera.z > frustumLength)\n\
+    if (positionEC.z > frustumLength)\n\
     {\n\
         out_FragColor = vec4(1.0);\n\
         return;\n\
     }\n\
 \n\
-    vec2 pixelSize = czm_pixelRatio / czm_viewport.zw;\n\
-    float depthU = czm_readDepth(depthTexture, v_textureCoordinates - vec2(0.0, pixelSize.y));\n\
-    float depthD = czm_readDepth(depthTexture, v_textureCoordinates + vec2(0.0, pixelSize.y));\n\
-    float depthL = czm_readDepth(depthTexture, v_textureCoordinates - vec2(pixelSize.x, 0.0));\n\
-    float depthR = czm_readDepth(depthTexture, v_textureCoordinates + vec2(pixelSize.x, 0.0));\n\
-    vec3 normalInCamera = getNormalXEdge(posInCamera.xyz, depthU, depthD, depthL, depthR, pixelSize);\n\
+    vec3 normalEC = getNormalXEdge(positionEC);\n\
 \n\
     float ao = 0.0;\n\
-    vec2 sampleDirection = vec2(1.0, 0.0);\n\
-    float gapAngle = 90.0 * czm_radiansPerDegree;\n\
 \n\
-    // RandomNoise\n\
-    float randomVal = texture(randomTexture, v_textureCoordinates / pixelSize / 255.0).x;\n\
-\n\
-    //Loop for each direction\n\
-    for (int i = 0; i < 4; i++)\n\
+    const int ANGLE_STEPS = 4;\n\
+    float angleStepScale = 1.0 / float(ANGLE_STEPS);\n\
+    float angleStep = angleStepScale * czm_twoPi;\n\
+    float cosStep = cos(angleStep);\n\
+    float sinStep = sin(angleStep);\n\
+    mat2 rotateStep = mat2(cosStep, sinStep, -sinStep, cosStep);\n\
+\n\
+    // Initial sampling direction (different for each pixel)\n\
+    const float randomTextureSize = 255.0;\n\
+    vec2 randomTexCoord = fract(gl_FragCoord.xy / randomTextureSize);\n\
+    float randomVal = texture(randomTexture, randomTexCoord).x;\n\
+    vec2 sampleDirection = vec2(cos(angleStep * randomVal), sin(angleStep * randomVal));\n\
+\n\
+    // Loop over sampling directions\n\
+    for (int i = 0; i < ANGLE_STEPS; i++)\n\
     {\n\
-        float newGapAngle = gapAngle * (float(i) + randomVal);\n\
-        float cosVal = cos(newGapAngle);\n\
-        float sinVal = sin(newGapAngle);\n\
+        sampleDirection = rotateStep * sampleDirection;\n\
 \n\
-        //Rotate Sampling Direction\n\
-        vec2 rotatedSampleDirection = vec2(cosVal * sampleDirection.x - sinVal * sampleDirection.y, sinVal * sampleDirection.x + cosVal * sampleDirection.y);\n\
         float localAO = 0.0;\n\
-        float localStepSize = stepSize;\n\
+        vec2 radialStep = stepSize * sampleDirection;\n\
 \n\
-        //Loop for each step\n\
         for (int j = 0; j < 6; j++)\n\
         {\n\
-            vec2 newCoords = v_textureCoordinates + rotatedSampleDirection * localStepSize * pixelSize;\n\
+            // Step along sampling direction, away from output pixel\n\
+            vec2 newCoords = floor(gl_FragCoord.xy + float(j + 1) * radialStep) + vec2(0.5);\n\
 \n\
-            //Exception Handling\n\
-            if(newCoords.x > 1.0 || newCoords.y > 1.0 || newCoords.x < 0.0 || newCoords.y < 0.0)\n\
+            // Exit if we stepped off the screen\n\
+            if (clamp(newCoords, vec2(0.0), czm_viewport.zw) != newCoords)\n\
             {\n\
                 break;\n\
             }\n\
 \n\
-            float stepDepthInfo = czm_readDepth(depthTexture, newCoords);\n\
-            vec4 stepPosInCamera = clipToEye(newCoords, stepDepthInfo);\n\
-            vec3 diffVec = stepPosInCamera.xyz - posInCamera.xyz;\n\
-            float len = length(diffVec);\n\
+            vec3 stepPositionEC = pixelToEye(newCoords);\n\
+            vec3 stepVector = stepPositionEC - positionEC;\n\
+            float stepLength = length(stepVector);\n\
 \n\
-            if (len > lengthCap)\n\
+            if (stepLength > lengthCap)\n\
             {\n\
                 break;\n\
             }\n\
 \n\
-            float dotVal = clamp(dot(normalInCamera, normalize(diffVec)), 0.0, 1.0 );\n\
-            float weight = len / lengthCap;\n\
-            weight = 1.0 - weight * weight;\n\
-\n\
+            float dotVal = clamp(dot(normalEC, normalize(stepVector)), 0.0, 1.0);\n\
             if (dotVal < bias)\n\
             {\n\
                 dotVal = 0.0;\n\
             }\n\
 \n\
+            float weight = stepLength / lengthCap;\n\
+            weight = 1.0 - weight * weight;\n\
             localAO = max(localAO, dotVal * weight);\n\
-            localStepSize += stepSize;\n\
         }\n\
         ao += localAO;\n\
     }\n\
 \n\
-    ao /= 4.0;\n\
+    ao *= angleStepScale;\n\
     ao = 1.0 - clamp(ao, 0.0, 1.0);\n\
     ao = pow(ao, intensity);\n\
     out_FragColor = vec4(vec3(ao), 1.0);\n\

package/Source/Shaders/PostProcessStages/FilmicTonemapping.glsl

@@ -4,6 +4,8 @@ in vec2 v_textureCoordinates;
 
 #ifdef AUTO_EXPOSURE
 uniform sampler2D autoExposure;
+#else
+uniform float exposure;
 #endif
 
 // See slides 142 and 143:
@@ -17,6 +19,8 @@ void main()
 #ifdef AUTO_EXPOSURE
     float exposure = texture(autoExposure, vec2(0.5)).r;
     color /= exposure;
+#else
+    color *= vec3(exposure);
 #endif
 
 	const float A = 0.22; // shoulder strength