@cesium/engine 12.0.1 → 13.1.0

package/Source/Scene/createGooglePhotorealistic3DTileset.js

@@ -4,23 +4,37 @@ import defined from "../Core/defined.js";
 import IonResource from "../Core/IonResource.js";
 import GoogleMaps from "../Core/GoogleMaps.js";
 import Resource from "../Core/Resource.js";
+import oneTimeWarning from "../Core/oneTimeWarning.js";
+import deprecationWarning from "../Core/deprecationWarning.js";
 
 /**
- * Creates a {@link Cesium3DTileset} instance for the Google Photorealistic 3D Tiles tileset.
+ * Creates a {@link Cesium3DTileset} instance for the Google Photorealistic 3D
+ * Tiles tileset.
+ *
+ * Google Photorealistic 3D Tiles can only be used with the Google geocoder.  To
+ * confirm that you are aware of this restriction pass
+ * `usingOnlyWithGoogleGeocoder: true` to the apiOptions.  Otherwise a one time
+ * warning will be displayed when this function is called.
  *
  * @function
  *
- * @param {string} [key=GoogleMaps.defaultApiKey] Your API key to access Google Photorealistic 3D Tiles. See {@link https://developers.google.com/maps/documentation/javascript/get-api-key} for instructions on how to create your own key.
- * @param {Cesium3DTileset.ConstructorOptions} [options] An object describing initialization options.
+ * @param {object} [apiOptions]
+ * @param {string} [apiOptions.key=GoogleMaps.defaultApiKey] Your API key to access Google Photorealistic 3D Tiles. See {@link https://developers.google.com/maps/documentation/javascript/get-api-key} for instructions on how to create your own key.
+ * @param {true} [apiOptions.onlyUsingWithGoogleGeocoder] Confirmation that this tileset will only be used with the Google geocoder.
+ * @param {Cesium3DTileset.ConstructorOptions} [tilesetOptions] An object describing initialization options.
  * @returns {Promise<Cesium3DTileset>}
  *
  * @see GoogleMaps
  *
  * @example
- * const viewer = new Cesium.Viewer("cesiumContainer");
+ * const viewer = new Cesium.Viewer("cesiumContainer", {
+ *   geocoder: Cesium.IonGeocodeProviderType.GOOGLE
+ * });
  *
  * try {
- *   const tileset = await Cesium.createGooglePhotorealistic3DTileset();
+ *   const tileset = await Cesium.createGooglePhotorealistic3DTileset({
+ *      onlyUsingWithGoogleGeocoder: true,
+ *   });
  *   viewer.scene.primitives.add(tileset));
  * } catch (error) {
  *   console.log(`Error creating tileset: ${error}`);
@@ -30,27 +44,52 @@ import Resource from "../Core/Resource.js";
  * // Use your own Google Maps API key
  * Cesium.GoogleMaps.defaultApiKey = "your-api-key";
  *
- * const viewer = new Cesium.Viewer("cesiumContainer");
+ * const viewer = new Cesium.Viewer("cesiumContainer". {
+ *   geocoder: Cesium.IonGeocodeProviderType.GOOGLE
+ * });
  *
  * try {
- *   const tileset = await Cesium.createGooglePhotorealistic3DTileset();
+ *   const tileset = await Cesium.createGooglePhotorealistic3DTileset({
+ *      onlyUsingWithGoogleGeocoder: true,
+ *   });
  *   viewer.scene.primitives.add(tileset));
  * } catch (error) {
  *   console.log(`Error creating tileset: ${error}`);
  * }
  */
-async function createGooglePhotorealistic3DTileset(key, options) {
-  options = defaultValue(options, {});
-  options.cacheBytes = defaultValue(options.cacheBytes, 1536 * 1024 * 1024);
-  options.maximumCacheOverflowBytes = defaultValue(
-    options.maximumCacheOverflowBytes,
+async function createGooglePhotorealistic3DTileset(apiOptions, tilesetOptions) {
+  tilesetOptions = defaultValue(tilesetOptions, {});
+  tilesetOptions.cacheBytes = defaultValue(
+    tilesetOptions.cacheBytes,
+    1536 * 1024 * 1024,
+  );
+  tilesetOptions.maximumCacheOverflowBytes = defaultValue(
+    tilesetOptions.maximumCacheOverflowBytes,
     1024 * 1024 * 1024,
   );
-  options.enableCollision = defaultValue(options.enableCollision, true);
+  tilesetOptions.enableCollision = defaultValue(
+    tilesetOptions.enableCollision,
+    true,
+  );
 
-  key = defaultValue(key, GoogleMaps.defaultApiKey);
+  apiOptions = defaultValue(apiOptions, defaultValue.EMPTY_OBJECT);
+  if (typeof apiOptions === "string") {
+    deprecationWarning(
+      "createGooglePhotorealistic3DTileset(key)",
+      "createGooglePhotorealistic3DTileset(key) has been deprecated.   It is replaced by createGooglePhotorealistic3DTileset({key}).  It will be removed in Cesium 1.126.",
+    );
+    apiOptions = { key: apiOptions };
+  }
+  if (!apiOptions.onlyUsingWithGoogleGeocoder) {
+    oneTimeWarning(
+      "google-tiles-with-google-geocoder",
+      "Only the Google geocoder can be used with Google Photorealistic 3D Tiles.  Set the `geocode` property of Viewer constructor options.  You can set additionalOptions.onlyUsingWithGoogleGeocoder to hide this warning once you have configured the geocoder.",
+    );
+  }
+
+  const key = defaultValue(apiOptions.key, GoogleMaps.defaultApiKey);
   if (!defined(key)) {
-    return requestCachedIonTileset(options);
+    return requestCachedIonTileset(tilesetOptions);
   }
 
   let credits;
@@ -67,7 +106,7 @@ async function createGooglePhotorealistic3DTileset(key, options) {
     credits: credits,
   });
 
-  return Cesium3DTileset.fromUrl(resource, options);
+  return Cesium3DTileset.fromUrl(resource, tilesetOptions);
 }
 
 const metadataCache = {};

package/Source/Scene/getMetadataProperty.js

@@ -0,0 +1,48 @@
+import defined from "../Core/defined.js";
+
+/**
+ * Return the `PropertyTextureProperty` from the given `StructuralMetadata`
+ * that matches the given description.
+ *
+ * If the given structural metadata is `undefined`, then `undefined` is returned.
+ *
+ * Otherwise, this method will check all the property textures in the given
+ * structural metadata.
+ *
+ * If it finds a property texture that has a class with an `_id` that matches
+ * the given name, and that contains a property for the given property name, then
+ * this property is returned.
+ *
+ * Otherwise, `undefined` is returned
+ *
+ * @param {StructuralMetadata} structuralMetadata The structural metadata
+ * @param {string} className The name of the metadata class
+ * @param {string} propertyName The name of the metadata property
+ * @returns {PropertyTextureProperty|undefined}
+ * @private
+ */
+function getMetadataProperty(structuralMetadata, className, propertyName) {
+  if (!defined(structuralMetadata)) {
+    return undefined;
+  }
+  const propertyTextures = structuralMetadata.propertyTextures;
+  for (const propertyTexture of propertyTextures) {
+    const metadataClass = propertyTexture.class;
+    if (metadataClass.id === className) {
+      const properties = propertyTexture.properties;
+      const property = properties[propertyName];
+      if (defined(property)) {
+        return property;
+      }
+    }
+  }
+  // Note: This could check for property attributes in a similar
+  // way. But since picking arbitrary property attributes via the
+  // frame buffer is not supported yet, returning "undefined" here
+  // causes the picking to bail out early and safely when no
+  // property texture was found.
+  // See https://github.com/CesiumGS/cesium/issues/12225
+  return undefined;
+}
+
+export default getMetadataProperty;

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

@@ -4,7 +4,7 @@ float czm_reverseLogDepth(float logZ)
     float near = czm_currentFrustum.x;
     float far = czm_currentFrustum.y;
     float log2Depth = logZ * czm_log2FarDepthFromNearPlusOne;
-    float depthFromNear = pow(2.0, log2Depth) - 1.0;
+    float depthFromNear = exp2(log2Depth) - 1.0;
     return far * (1.0 - near / (depthFromNear + near)) / (far - near);
 #endif
     return logZ;

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

@@ -5,7 +5,7 @@ export default "float czm_reverseLogDepth(float logZ)\n\
     float near = czm_currentFrustum.x;\n\
     float far = czm_currentFrustum.y;\n\
     float log2Depth = logZ * czm_log2FarDepthFromNearPlusOne;\n\
-    float depthFromNear = pow(2.0, log2Depth) - 1.0;\n\
+    float depthFromNear = exp2(log2Depth) - 1.0;\n\
     return far * (1.0 - near / (depthFromNear + near)) / (far - near);\n\
 #endif\n\
     return logZ;\n\

package/Source/Shaders/ConvolveSpecularMapFS.glsl

@@ -62,7 +62,7 @@ void main() {
 
             float NdotL = max(dot(V, L), 0.0);
             if (NdotL > 0.0) {
-                color += vec4(texture(u_radianceTexture, L).rgb, 1.0) * NdotL;
+                color += vec4(czm_textureCube(u_radianceTexture, L).rgb, 1.0) * NdotL;
                 weight += NdotL;
             }
         }

package/Source/Shaders/ConvolveSpecularMapFS.js

@@ -63,7 +63,7 @@ void main() {\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\
+                color += vec4(czm_textureCube(u_radianceTexture, L).rgb, 1.0) * NdotL;\n\
                 weight += NdotL;\n\
             }\n\
         }\n\

package/Source/Shaders/DepthPlaneVS.glsl

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

package/Source/Shaders/Model/ModelFS.glsl

@@ -28,6 +28,13 @@ SelectedFeature selectedFeature;
 
 void main()
 {
+    #ifdef HAS_POINT_CLOUD_SHOW_STYLE
+        if (v_pointCloudShow == 0.0)
+        {
+            discard;
+        }
+    #endif
+
     #ifdef HAS_MODEL_SPLITTER
     modelSplitterStage();
     #endif

package/Source/Shaders/Model/ModelFS.js

@@ -29,6 +29,13 @@ SelectedFeature selectedFeature;\n\
 \n\
 void main()\n\
 {\n\
+    #ifdef HAS_POINT_CLOUD_SHOW_STYLE\n\
+        if (v_pointCloudShow == 0.0)\n\
+        {\n\
+            discard;\n\
+        }\n\
+    #endif\n\
+\n\
     #ifdef HAS_MODEL_SPLITTER\n\
     modelSplitterStage();\n\
     #endif\n\

package/Source/Shaders/Model/ModelVS.glsl

@@ -145,5 +145,13 @@ void main()
         gl_PointSize *= show;
     #endif
 
-    gl_Position = show * positionClip;
+    // Important NOT to compute gl_Position = show * positionClip or we hit:
+    // https://github.com/CesiumGS/cesium/issues/11270
+    //
+    // We will discard points with v_pointCloudShow == 0 in the fragment shader.
+    gl_Position = positionClip;
+
+    #ifdef HAS_POINT_CLOUD_SHOW_STYLE
+    v_pointCloudShow = show;
+    #endif
 }

package/Source/Shaders/Model/ModelVS.js

@@ -146,6 +146,14 @@ void main()\n\
         gl_PointSize *= show;\n\
     #endif\n\
 \n\
-    gl_Position = show * positionClip;\n\
+    // Important NOT to compute gl_Position = show * positionClip or we hit:\n\
+    // https://github.com/CesiumGS/cesium/issues/11270\n\
+    //\n\
+    // We will discard points with v_pointCloudShow == 0 in the fragment shader.\n\
+    gl_Position = positionClip;\n\
+\n\
+    #ifdef HAS_POINT_CLOUD_SHOW_STYLE\n\
+    v_pointCloudShow = show;\n\
+    #endif\n\
 }\n\
 ";

package/Source/Shaders/PostProcessStages/AmbientOcclusionGenerate.glsl

@@ -5,16 +5,21 @@ uniform sampler2D depthTexture;
 uniform float intensity;
 uniform float bias;
 uniform float lengthCap;
-uniform float stepSize;
-uniform float frustumLength;
+uniform int stepCount;
+uniform int directionCount;
 
-vec3 pixelToEye(vec2 screenCoordinate)
+vec4 pixelToEye(vec2 screenCoordinate)
 {
     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);
-    return posEC.xyz / posEC.w;
+    posEC = posEC / posEC.w;
+    // Avoid numerical error at far plane
+    if (depth >= 1.0) {
+        posEC.z = czm_currentFrustum.y;
+    }
+    return posEC;
 }
 
 // Reconstruct surface normal in eye coordinates, avoiding edges
@@ -22,10 +27,10 @@ vec3 getNormalXEdge(vec3 positionEC)
 {
     // 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));
+    vec3 positionLeft = pixelToEye(centerCoord + vec2(-1.0, 0.0)).xyz;
+    vec3 positionRight = pixelToEye(centerCoord + vec2(1.0, 0.0)).xyz;
+    vec3 positionUp = pixelToEye(centerCoord + vec2(0.0, 1.0)).xyz;
+    vec3 positionDown = pixelToEye(centerCoord + vec2(0.0, -1.0)).xyz;
 
     // Compute potential tangent vectors
     vec3 dx0 = positionEC - positionLeft;
@@ -40,22 +45,35 @@ vec3 getNormalXEdge(vec3 positionEC)
     return normalize(cross(dx, dy));
 }
 
+const float sqrtTwoPi = sqrt(czm_twoPi);
+
+float gaussian(float x, float standardDeviation) {
+    float argument = x / standardDeviation;
+    return exp(-0.5 * argument * argument) / (sqrtTwoPi * standardDeviation);
+}
+
 void main(void)
 {
-    vec3 positionEC = pixelToEye(gl_FragCoord.xy);
+    vec4 positionEC = pixelToEye(gl_FragCoord.xy);
 
-    if (positionEC.z > frustumLength)
+    // Exit if we are too close to the back of the frustum, where the depth value is invalid.
+    float maxValidDepth = czm_currentFrustum.y - lengthCap;
+    if (-positionEC.z > maxValidDepth)
     {
         out_FragColor = vec4(1.0);
         return;
     }
 
-    vec3 normalEC = getNormalXEdge(positionEC);
+    vec3 normalEC = getNormalXEdge(positionEC.xyz);
+    float gaussianVariance = lengthCap * sqrt(-positionEC.z);
+    // Choose a step length such that the marching stops just before 3 * variance.
+    float stepLength = 3.0 * gaussianVariance / (float(stepCount) + 1.0);
+    float metersPerPixel = czm_metersPerPixel(positionEC, 1.0);
+    // Minimum step is 1 pixel to avoid double sampling
+    float pixelsPerStep = max(stepLength / metersPerPixel, 1.0);
+    stepLength = pixelsPerStep * metersPerPixel;
 
-    float ao = 0.0;
-
-    const int ANGLE_STEPS = 4;
-    float angleStepScale = 1.0 / float(ANGLE_STEPS);
+    float angleStepScale = 1.0 / float(directionCount);
     float angleStep = angleStepScale * czm_twoPi;
     float cosStep = cos(angleStep);
     float sinStep = sin(angleStep);
@@ -67,48 +85,59 @@ void main(void)
     float randomVal = texture(randomTexture, randomTexCoord).x;
     vec2 sampleDirection = vec2(cos(angleStep * randomVal), sin(angleStep * randomVal));
 
+    float ao = 0.0;
     // Loop over sampling directions
-    for (int i = 0; i < ANGLE_STEPS; i++)
+#if __VERSION__ == 300
+    for (int i = 0; i < directionCount; i++)
+    {
+#else
+    for (int i = 0; i < 16; i++)
     {
+        if (i >= directionCount) {
+            break;
+        }
+#endif
         sampleDirection = rotateStep * sampleDirection;
 
         float localAO = 0.0;
-        vec2 radialStep = stepSize * sampleDirection;
+        vec2 radialStep = pixelsPerStep * sampleDirection;
 
-        for (int j = 0; j < 6; j++)
+#if __VERSION__ == 300
+        for (int j = 0; j < stepCount; j++)
+        {
+#else
+        for (int j = 0; j < 64; j++)
         {
+            if (j >= stepCount) {
+                break;
+            }
+#endif
             // Step along sampling direction, away from output pixel
-            vec2 newCoords = floor(gl_FragCoord.xy + float(j + 1) * radialStep) + vec2(0.5);
+            vec2 samplePixel = floor(gl_FragCoord.xy + float(j + 1) * radialStep) + vec2(0.5);
 
             // Exit if we stepped off the screen
-            if (clamp(newCoords, vec2(0.0), czm_viewport.zw) != newCoords)
-            {
+            if (clamp(samplePixel, vec2(0.0), czm_viewport.zw) != samplePixel) {
                 break;
             }
 
-            vec3 stepPositionEC = pixelToEye(newCoords);
-            vec3 stepVector = stepPositionEC - positionEC;
-            float stepLength = length(stepVector);
-
-            if (stepLength > lengthCap)
-            {
-                break;
-            }
+            // Compute step vector from output point to sampled point
+            vec4 samplePositionEC = pixelToEye(samplePixel);
+            vec3 stepVector = samplePositionEC.xyz - positionEC.xyz;
 
+            // Estimate the angle from the surface normal.
             float dotVal = clamp(dot(normalEC, normalize(stepVector)), 0.0, 1.0);
-            if (dotVal < bias)
-            {
-                dotVal = 0.0;
-            }
+            dotVal = czm_branchFreeTernary(dotVal > bias, dotVal, 0.0);
+            dotVal = czm_branchFreeTernary(-samplePositionEC.z <= maxValidDepth, dotVal, 0.0);
 
-            float weight = stepLength / lengthCap;
-            weight = 1.0 - weight * weight;
-            localAO = max(localAO, dotVal * weight);
+            // Weight contribution based on the distance from the output point
+            float sampleDistance = length(stepVector);
+            float weight = gaussian(sampleDistance, gaussianVariance);
+            localAO += weight * dotVal;
         }
         ao += localAO;
     }
 
-    ao *= angleStepScale;
+    ao *= angleStepScale * stepLength;
     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

@@ -6,16 +6,21 @@ uniform sampler2D depthTexture;\n\
 uniform float intensity;\n\
 uniform float bias;\n\
 uniform float lengthCap;\n\
-uniform float stepSize;\n\
-uniform float frustumLength;\n\
+uniform int stepCount;\n\
+uniform int directionCount;\n\
 \n\
-vec3 pixelToEye(vec2 screenCoordinate)\n\
+vec4 pixelToEye(vec2 screenCoordinate)\n\
 {\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\
-    return posEC.xyz / posEC.w;\n\
+    posEC = posEC / posEC.w;\n\
+    // Avoid numerical error at far plane\n\
+    if (depth >= 1.0) {\n\
+        posEC.z = czm_currentFrustum.y;\n\
+    }\n\
+    return posEC;\n\
 }\n\
 \n\
 // Reconstruct surface normal in eye coordinates, avoiding edges\n\
@@ -23,10 +28,10 @@ vec3 getNormalXEdge(vec3 positionEC)\n\
 {\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\
+    vec3 positionLeft = pixelToEye(centerCoord + vec2(-1.0, 0.0)).xyz;\n\
+    vec3 positionRight = pixelToEye(centerCoord + vec2(1.0, 0.0)).xyz;\n\
+    vec3 positionUp = pixelToEye(centerCoord + vec2(0.0, 1.0)).xyz;\n\
+    vec3 positionDown = pixelToEye(centerCoord + vec2(0.0, -1.0)).xyz;\n\
 \n\
     // Compute potential tangent vectors\n\
     vec3 dx0 = positionEC - positionLeft;\n\
@@ -41,22 +46,35 @@ vec3 getNormalXEdge(vec3 positionEC)\n\
     return normalize(cross(dx, dy));\n\
 }\n\
 \n\
+const float sqrtTwoPi = sqrt(czm_twoPi);\n\
+\n\
+float gaussian(float x, float standardDeviation) {\n\
+    float argument = x / standardDeviation;\n\
+    return exp(-0.5 * argument * argument) / (sqrtTwoPi * standardDeviation);\n\
+}\n\
+\n\
 void main(void)\n\
 {\n\
-    vec3 positionEC = pixelToEye(gl_FragCoord.xy);\n\
+    vec4 positionEC = pixelToEye(gl_FragCoord.xy);\n\
 \n\
-    if (positionEC.z > frustumLength)\n\
+    // Exit if we are too close to the back of the frustum, where the depth value is invalid.\n\
+    float maxValidDepth = czm_currentFrustum.y - lengthCap;\n\
+    if (-positionEC.z > maxValidDepth)\n\
     {\n\
         out_FragColor = vec4(1.0);\n\
         return;\n\
     }\n\
 \n\
-    vec3 normalEC = getNormalXEdge(positionEC);\n\
+    vec3 normalEC = getNormalXEdge(positionEC.xyz);\n\
+    float gaussianVariance = lengthCap * sqrt(-positionEC.z);\n\
+    // Choose a step length such that the marching stops just before 3 * variance.\n\
+    float stepLength = 3.0 * gaussianVariance / (float(stepCount) + 1.0);\n\
+    float metersPerPixel = czm_metersPerPixel(positionEC, 1.0);\n\
+    // Minimum step is 1 pixel to avoid double sampling\n\
+    float pixelsPerStep = max(stepLength / metersPerPixel, 1.0);\n\
+    stepLength = pixelsPerStep * metersPerPixel;\n\
 \n\
-    float ao = 0.0;\n\
-\n\
-    const int ANGLE_STEPS = 4;\n\
-    float angleStepScale = 1.0 / float(ANGLE_STEPS);\n\
+    float angleStepScale = 1.0 / float(directionCount);\n\
     float angleStep = angleStepScale * czm_twoPi;\n\
     float cosStep = cos(angleStep);\n\
     float sinStep = sin(angleStep);\n\
@@ -68,48 +86,59 @@ void main(void)\n\
     float randomVal = texture(randomTexture, randomTexCoord).x;\n\
     vec2 sampleDirection = vec2(cos(angleStep * randomVal), sin(angleStep * randomVal));\n\
 \n\
+    float ao = 0.0;\n\
     // Loop over sampling directions\n\
-    for (int i = 0; i < ANGLE_STEPS; i++)\n\
+#if __VERSION__ == 300\n\
+    for (int i = 0; i < directionCount; i++)\n\
+    {\n\
+#else\n\
+    for (int i = 0; i < 16; i++)\n\
     {\n\
+        if (i >= directionCount) {\n\
+            break;\n\
+        }\n\
+#endif\n\
         sampleDirection = rotateStep * sampleDirection;\n\
 \n\
         float localAO = 0.0;\n\
-        vec2 radialStep = stepSize * sampleDirection;\n\
+        vec2 radialStep = pixelsPerStep * sampleDirection;\n\
 \n\
-        for (int j = 0; j < 6; j++)\n\
+#if __VERSION__ == 300\n\
+        for (int j = 0; j < stepCount; j++)\n\
+        {\n\
+#else\n\
+        for (int j = 0; j < 64; j++)\n\
         {\n\
+            if (j >= stepCount) {\n\
+                break;\n\
+            }\n\
+#endif\n\
             // Step along sampling direction, away from output pixel\n\
-            vec2 newCoords = floor(gl_FragCoord.xy + float(j + 1) * radialStep) + vec2(0.5);\n\
+            vec2 samplePixel = floor(gl_FragCoord.xy + float(j + 1) * radialStep) + vec2(0.5);\n\
 \n\
             // Exit if we stepped off the screen\n\
-            if (clamp(newCoords, vec2(0.0), czm_viewport.zw) != newCoords)\n\
-            {\n\
+            if (clamp(samplePixel, vec2(0.0), czm_viewport.zw) != samplePixel) {\n\
                 break;\n\
             }\n\
 \n\
-            vec3 stepPositionEC = pixelToEye(newCoords);\n\
-            vec3 stepVector = stepPositionEC - positionEC;\n\
-            float stepLength = length(stepVector);\n\
-\n\
-            if (stepLength > lengthCap)\n\
-            {\n\
-                break;\n\
-            }\n\
+            // Compute step vector from output point to sampled point\n\
+            vec4 samplePositionEC = pixelToEye(samplePixel);\n\
+            vec3 stepVector = samplePositionEC.xyz - positionEC.xyz;\n\
 \n\
+            // Estimate the angle from the surface normal.\n\
             float dotVal = clamp(dot(normalEC, normalize(stepVector)), 0.0, 1.0);\n\
-            if (dotVal < bias)\n\
-            {\n\
-                dotVal = 0.0;\n\
-            }\n\
+            dotVal = czm_branchFreeTernary(dotVal > bias, dotVal, 0.0);\n\
+            dotVal = czm_branchFreeTernary(-samplePositionEC.z <= maxValidDepth, dotVal, 0.0);\n\
 \n\
-            float weight = stepLength / lengthCap;\n\
-            weight = 1.0 - weight * weight;\n\
-            localAO = max(localAO, dotVal * weight);\n\
+            // Weight contribution based on the distance from the output point\n\
+            float sampleDistance = length(stepVector);\n\
+            float weight = gaussian(sampleDistance, gaussianVariance);\n\
+            localAO += weight * dotVal;\n\
         }\n\
         ao += localAO;\n\
     }\n\
 \n\
-    ao *= angleStepScale;\n\
+    ao *= angleStepScale * stepLength;\n\
     ao = 1.0 - clamp(ao, 0.0, 1.0);\n\
     ao = pow(ao, intensity);\n\
     out_FragColor = vec4(vec3(ao), 1.0);\n\