@cesium/engine 22.0.0 → 22.2.0

package/Source/Scene/Google2DImageryProvider.js

@@ -101,6 +101,8 @@ function Google2DImageryProvider(options) {
     key: encodeURIComponent(options.key),
   });
 
+  this._resource = resource.clone();
+
   let credit;
   if (defined(options.credit)) {
     credit = options.credit;
@@ -312,7 +314,7 @@ Object.defineProperties(Google2DImageryProvider.prototype, {
  * });
  * @example
  * // Google 2D roadmap overlay with custom styles
- * const googleTileProvider = Cesium.Google2DImageryProvider.fromIonAssetId({
+ * const googleTilesProvider = Cesium.Google2DImageryProvider.fromIonAssetId({
  *     assetId: 3830184,
  *     overlayLayerType: "layerRoadmap",
  *     styles: [
@@ -403,7 +405,7 @@ Google2DImageryProvider.fromIonAssetId = async function (options) {
  * // Google 2D roadmap overlay with custom styles
  * Cesium.GoogleMaps.defaultApiKey = "your-api-key";
  *
- * const googleTileProvider = Cesium.Google2DImageryProvider.fromUrl({
+ * const googleTilesProvider = Cesium.Google2DImageryProvider.fromUrl({
  *     overlayLayerType: "layerRoadmap",
  *     styles: [
  *         {
@@ -492,7 +494,7 @@ Google2DImageryProvider.prototype.requestImage = function (
   }
 
   // Asynchronously request and populate _attributionsByLevel if it hasn't been already. We do this here so that the promise can be properly awaited.
-  if (promise && !defined(this._attributionsByLevel)) {
+  if (!defined(this._attributionsByLevel)) {
     return Promise.all([promise, this.getViewportCredits()]).then(
       (results) => results[0],
     );
@@ -533,12 +535,7 @@ Google2DImageryProvider.prototype.getViewportCredits = async function () {
   const promises = [];
   for (let level = 0; level < maximumLevel + 1; level++) {
     promises.push(
-      fetchViewportAttribution(
-        this._viewportUrl,
-        this._key,
-        this._session,
-        level,
-      ),
+      fetchViewportAttribution(this._resource, this._viewportUrl, level),
     );
   }
   const results = await Promise.all(promises);
@@ -559,12 +556,10 @@ Google2DImageryProvider.prototype.getViewportCredits = async function () {
   return attributionsByLevel;
 };
 
-async function fetchViewportAttribution(url, key, session, level) {
-  const viewport = await Resource.fetch({
-    url: url,
+async function fetchViewportAttribution(resource, url, level) {
+  const viewportResource = resource.getDerivedResource({
+    url,
     queryParameters: {
-      key,
-      session,
       zoom: level,
       north: 90,
       south: -90,
@@ -573,7 +568,7 @@ async function fetchViewportAttribution(url, key, session, level) {
     },
     data: JSON.stringify(Frozen.EMPTY_OBJECT),
   });
-  const viewportJson = JSON.parse(viewport);
+  const viewportJson = await viewportResource.fetchJson();
   return viewportJson.copyright;
 }
 

package/Source/Scene/LabelCollection.js

@@ -118,6 +118,7 @@ function unbindGlyphBillboard(labelCollection, glyph) {
   const billboard = glyph.billboard;
   if (defined(billboard)) {
     billboard.show = false;
+    billboard._clampedPosition = undefined;
     if (defined(billboard._removeCallbackFunc)) {
       billboard._removeCallbackFunc();
       billboard._removeCallbackFunc = undefined;

package/Source/Scene/PickFramebuffer.js

@@ -4,6 +4,10 @@ import defined from "../Core/defined.js";
 import destroyObject from "../Core/destroyObject.js";
 import FramebufferManager from "../Renderer/FramebufferManager.js";
 import PassState from "../Renderer/PassState.js";
+import PixelDatatype from "../Renderer/PixelDatatype.js";
+import PixelFormat from "../Core/PixelFormat.js";
+import Sync from "../Renderer/Sync.js";
+import RuntimeError from "../Core/RuntimeError.js";
 
 /**
  * @private
@@ -27,47 +31,18 @@ function PickFramebuffer(context) {
   this._height = 0;
 }
 
-PickFramebuffer.prototype.begin = function (screenSpaceRectangle, viewport) {
-  const context = this._context;
-  const { width, height } = viewport;
-
-  BoundingRectangle.clone(
-    screenSpaceRectangle,
-    this._passState.scissorTest.rectangle,
-  );
-
-  // Create or recreate renderbuffers and framebuffer used for picking
-  this._width = width;
-  this._height = height;
-  this._fb.update(context, width, height);
-  this._passState.framebuffer = this._fb.framebuffer;
-
-  this._passState.viewport.width = width;
-  this._passState.viewport.height = height;
-
-  return this._passState;
-};
-
 /**
- * Return the picked objects rendered within a given rectangle.
+ * Return the picked object(s) rendered within a given rectangle.
  *
- * @param {BoundingRectangle} screenSpaceRectangle
+ * @private
+ * @param {object} context The active context.
+ * @param {Uint8Array|Uint16Array|Float32Array|Uint32Array} pixels The pixels in the specified rectangle.
+ * @param {number} width The rectangle width.
+ * @param {number} height The rectangle height.
  * @param {number} [limit=1] If supplied, stop iterating after collecting this many objects.
  * @returns {object[]} A list of rendered objects, ordered by distance to the middle of the rectangle.
  */
-PickFramebuffer.prototype.end = function (screenSpaceRectangle, limit = 1) {
-  const width = screenSpaceRectangle.width ?? 1.0;
-  const height = screenSpaceRectangle.height ?? 1.0;
-
-  const context = this._context;
-  const pixels = context.readPixels({
-    x: screenSpaceRectangle.x,
-    y: screenSpaceRectangle.y,
-    width: width,
-    height: height,
-    framebuffer: this._fb.framebuffer,
-  });
-
+function pickObjectsFromPixels(context, pixels, width, height, limit = 1) {
   const max = Math.max(width, height);
   const length = max * max;
   const halfWidth = Math.floor(width * 0.5);
@@ -121,6 +96,119 @@ PickFramebuffer.prototype.end = function (screenSpaceRectangle, limit = 1) {
     y += dy;
   }
   return [...objects];
+}
+
+PickFramebuffer.prototype.begin = function (screenSpaceRectangle, viewport) {
+  const context = this._context;
+  const { width, height } = viewport;
+
+  BoundingRectangle.clone(
+    screenSpaceRectangle,
+    this._passState.scissorTest.rectangle,
+  );
+
+  // Create or recreate renderbuffers and framebuffer used for picking
+  this._width = width;
+  this._height = height;
+  this._fb.update(context, width, height);
+  this._passState.framebuffer = this._fb.framebuffer;
+
+  this._passState.viewport.width = width;
+  this._passState.viewport.height = height;
+
+  return this._passState;
+};
+
+/**
+ * Return the picked objects rendered within a given rectangle using asynchronously without stalling the GPU.
+ * Requires WebGL2.
+ *
+ * @param {BoundingRectangle} screenSpaceRectangle
+ * @param {FrameState} frameState
+ * @param {number} [limit=1] If supplied, stop iterating after collecting this many objects.
+ * @returns {Promise<object[]>} A list of rendered objects, ordered by distance to the middle of the rectangle.
+ *
+ * @exception {RuntimeError} Async Picking Request Timeout.
+ * @exception {DeveloperError} A WebGL 2 context is required.
+ */
+PickFramebuffer.prototype.endAsync = async function (
+  screenSpaceRectangle,
+  frameState,
+  limit = 1,
+) {
+  const width = screenSpaceRectangle.width ?? 1.0;
+  const height = screenSpaceRectangle.height ?? 1.0;
+
+  const context = this._context;
+  const framebuffer = this._fb.framebuffer;
+
+  let pixelDatatype = PixelDatatype.UNSIGNED_BYTE;
+  let pixelFormat = PixelFormat.RGBA;
+
+  if (defined(framebuffer) && framebuffer.numberOfColorAttachments > 0) {
+    pixelDatatype = framebuffer.getColorTexture(0).pixelDatatype;
+    pixelFormat = framebuffer.getColorTexture(0).pixelFormat;
+  }
+
+  const pbo = context.readPixelsToPBO({
+    x: screenSpaceRectangle.x,
+    y: screenSpaceRectangle.y,
+    width: width,
+    height: height,
+    framebuffer: framebuffer,
+  });
+
+  const sync = Sync.create({
+    context: context,
+  });
+
+  // Wait for the GPU to signal that it is ready to readback the PBO data
+  try {
+    await sync.waitForSignal((next) => frameState.afterRender.push(next));
+    const pixels = PixelFormat.createTypedArray(
+      pixelFormat,
+      pixelDatatype,
+      width,
+      height,
+    );
+    pbo.getBufferData(pixels);
+    const pickedObjects = pickObjectsFromPixels(
+      context,
+      pixels,
+      width,
+      height,
+      limit,
+    );
+    return pickedObjects;
+  } catch (e) {
+    throw new RuntimeError("Async Picking Request Timeout");
+  } finally {
+    sync.destroy();
+    pbo.destroy();
+  }
+};
+
+/**
+ * Return the picked objects rendered within a given rectangle.
+ *
+ * @param {BoundingRectangle} screenSpaceRectangle
+ * @param {number} [limit=1] If supplied, stop iterating after collecting this many objects.
+ * @returns {object[]} A list of rendered objects, ordered by distance to the middle of the rectangle.
+ */
+PickFramebuffer.prototype.end = function (screenSpaceRectangle, limit = 1) {
+  const width = screenSpaceRectangle.width ?? 1.0;
+  const height = screenSpaceRectangle.height ?? 1.0;
+
+  const context = this._context;
+  const pixels = context.readPixels({
+    x: screenSpaceRectangle.x,
+    y: screenSpaceRectangle.y,
+    width: width,
+    height: height,
+    framebuffer: this._fb.framebuffer,
+  });
+
+  return pickObjectsFromPixels(context, pixels, width, height, limit);
 };
 
 /**

package/Source/Scene/Picking.js

@@ -8,6 +8,7 @@ import Color from "../Core/Color.js";
 import defined from "../Core/defined.js";
 import DeveloperError from "../Core/DeveloperError.js";
 import Matrix4 from "../Core/Matrix4.js";
+import oneTimeWarning from "../Core/oneTimeWarning.js";
 import OrthographicFrustum from "../Core/OrthographicFrustum.js";
 import OrthographicOffCenterFrustum from "../Core/OrthographicOffCenterFrustum.js";
 import PerspectiveFrustum from "../Core/PerspectiveFrustum.js";
@@ -262,30 +263,21 @@ function computePickingDrawingBufferRectangle(
 }
 
 /**
- * Returns a list of objects with a <code>primitive</code> property that contains the first (top) primitives
- * in the scene at a particular window coordinate. Other properties may potentially be set depending on the
- * type of primitive and may be used to further identify the picked object.
- * <p>
- * When a feature of a 3D Tiles tileset is picked, <code>pick</code> returns a {@link Cesium3DTileFeature} object.
- * </p>
+ * Setup needed before picking.
+ *
  * @param {Scene} scene
  * @param {Cartesian2} windowPosition Window coordinates to perform picking on.
+ * @param {BoundingRectangle} drawingBufferRectangle The output drawing buffer recangle.
  * @param {number} [width=3] Width of the pick rectangle.
  * @param {number} [height=3] Height of the pick rectangle.
- * @param {number} [limit=1] If supplied, stop iterating after collecting this many objects.
- * @returns {object[]} List of objects containing the picked primitives.
  */
-Picking.prototype.pick = function (
+function pickBegin(
   scene,
   windowPosition,
+  drawingBufferRectangle,
   width,
   height,
-  limit = 1,
 ) {
-  //>>includeStart('debug', pragmas.debug);
-  Check.defined("windowPosition", windowPosition);
-  //>>includeEnd('debug');
-
   const { context, frameState, defaultView } = scene;
   const { viewport, pickFramebuffer } = defaultView;
 
@@ -304,12 +296,12 @@ Picking.prototype.pick = function (
     windowPosition,
     scratchPosition,
   );
-  const drawingBufferRectangle = computePickingDrawingBufferRectangle(
+  computePickingDrawingBufferRectangle(
     context.drawingBufferHeight,
     drawingBufferPosition,
     width,
     height,
-    scratchRectangle,
+    drawingBufferRectangle,
   );
 
   scene.jobScheduler.disableThisFrame();
@@ -334,9 +326,99 @@ Picking.prototype.pick = function (
 
   scene.updateAndExecuteCommands(passState, scratchColorZero);
   scene.resolveFramebuffers(passState);
+}
 
-  const pickedObjects = pickFramebuffer.end(drawingBufferRectangle, limit);
+/**
+ * Teardown needed after picking.
+ *
+ * @param {Scene} scene
+ */
+function pickEnd(scene) {
+  const { context } = scene;
   context.endFrame();
+}
+
+/**
+ * Same operation as {@link Picking#pick}, but returns a Promise that resolves asynchronously without blocking the main render thread.
+ * Requires WebGL2 else using synchronous fallback.
+ *
+ * @see Picking#pick
+ *
+ * @param {Scene} scene
+ * @param {Cartesian2} windowPosition Window coordinates to perform picking on.
+ * @param {number} [width=3] Width of the pick rectangle.
+ * @param {number} [height=3] Height of the pick rectangle.
+ * @param {number} [limit=1] If supplied, stop iterating after collecting this many objects.
+ * @returns {Promise<object[]>} List of objects containing the picked primitives.
+ *
+ * @exception {RuntimeError} Async Picking Request Timeout.
+ */
+Picking.prototype.pickAsync = async function (
+  scene,
+  windowPosition,
+  width,
+  height,
+  limit = 1,
+) {
+  //>>includeStart('debug', pragmas.debug);
+  Check.defined("windowPosition", windowPosition);
+  //>>includeEnd('debug');
+
+  const { context, frameState, defaultView } = scene;
+  const { pickFramebuffer } = defaultView;
+  const drawingBufferRectangle = scratchRectangle;
+  pickBegin(scene, windowPosition, drawingBufferRectangle, width, height);
+  let pickedObjects;
+  if (context.webgl2) {
+    pickedObjects = pickFramebuffer.endAsync(
+      drawingBufferRectangle,
+      frameState,
+      limit,
+    ); // Promise<Object[]>
+  } else {
+    pickedObjects = pickFramebuffer.end(drawingBufferRectangle, limit); // Object[]
+    pickedObjects = Promise.resolve(pickedObjects); // Promise<Object[]> Wrap as Promise
+    oneTimeWarning(
+      "picking-async-fallback",
+      "Fallback to synchronous picking because async operation requires WebGL2 context.",
+    );
+  }
+  pickEnd(scene);
+  return pickedObjects;
+};
+
+/**
+ * Returns a list of objects with a <code>primitive</code> property that contains the first (top) primitives
+ * in the scene at a particular window coordinate. Other properties may potentially be set depending on the
+ * type of primitive and may be used to further identify the picked object.
+ * <p>
+ * When a feature of a 3D Tiles tileset is picked, <code>pick</code> returns a {@link Cesium3DTileFeature} object.
+ * </p>
+ * @param {Scene} scene
+ * @param {Cartesian2} windowPosition Window coordinates to perform picking on.
+ * @param {number} [width=3] Width of the pick rectangle.
+ * @param {number} [height=3] Height of the pick rectangle.
+ * @param {number} [limit=1] If supplied, stop iterating after collecting this many objects.
+ * @returns {object[]} List of objects containing the picked primitives.
+ *
+ */
+Picking.prototype.pick = function (
+  scene,
+  windowPosition,
+  width,
+  height,
+  limit = 1,
+) {
+  //>>includeStart('debug', pragmas.debug);
+  Check.defined("windowPosition", windowPosition);
+  //>>includeEnd('debug');
+
+  const { defaultView } = scene;
+  const { pickFramebuffer } = defaultView;
+  const drawingBufferRectangle = scratchRectangle;
+  pickBegin(scene, windowPosition, drawingBufferRectangle, width, height);
+  const pickedObjects = pickFramebuffer.end(drawingBufferRectangle, limit); // Object[]
+  pickEnd(scene);
   return pickedObjects;
 };
 

package/Source/Scene/Scene.js

@@ -3932,14 +3932,15 @@ function callAfterRenderFunctions(scene) {
   // Functions are queued up during primitive update and executed here in case
   // the function modifies scene state that should remain constant over the frame.
   const functions = scene._frameState.afterRender;
-  for (let i = 0; i < functions.length; ++i) {
-    const shouldRequestRender = functions[i]();
+  const functionsCpy = functions.slice(); // Snapshot before iterate allows callbacks to add functions for next frame
+  functions.length = 0;
+
+  for (let i = 0; i < functionsCpy.length; ++i) {
+    const shouldRequestRender = functionsCpy[i]();
     if (shouldRequestRender) {
       scene.requestRender();
     }
   }
-
-  functions.length = 0;
 }
 
 function getGlobeHeight(scene) {
@@ -4517,6 +4518,37 @@ Scene.prototype.pick = function (windowPosition, width, height) {
   return this._picking.pick(this, windowPosition, width, height, 1)[0];
 };
 
+/**
+ * Performs the same operation as Scene.pick but asynchonosly without blocking the main render thread.
+ * Requires WebGL2 else using fallback.
+ *
+ * @example
+ * // On mouse over, color the feature yellow.
+ * handler.setInputAction(function(movement) {
+ *     const feature = scene.pickAsync(movement.endPosition).then(function(feature) {
+ *        if (feature instanceof Cesium.Cesium3DTileFeature) {
+ *            feature.color = Cesium.Color.YELLOW;
+ *        }
+ *     });
+ * }, Cesium.ScreenSpaceEventType.MOUSE_MOVE);
+ *
+ * @param {Cartesian2} windowPosition Window coordinates to perform picking on.
+ * @param {number} [width=3] Width of the pick rectangle.
+ * @param {number} [height=3] Height of the pick rectangle.
+ * @returns {Promise<Object | undefined>} Object containing the picked primitive or <code>undefined</code> if nothing is at the location.
+ *
+ * @see Scene#pick
+ */
+Scene.prototype.pickAsync = async function (windowPosition, width, height) {
+  const result = await this._picking.pickAsync(
+    this,
+    windowPosition,
+    width,
+    height,
+    1,
+  );
+  return result[0];
+};
 /**
  * Returns a {@link VoxelCell} for the voxel sample rendered at a particular window coordinate,
  * or <code>undefined</code> if no voxel is rendered at that position.

package/Source/Scene/TerrainFillMesh.js

@@ -1274,6 +1274,7 @@ function createFillMesh(tileProvider, frameState, tile, vertexArraysToDestroy) {
       vertexCount,
       minimumHeight,
       maximumHeight,
+      rectangle,
       BoundingSphere.fromOrientedBoundingBox(obb),
       computeOccludeePoint(
         tileProvider,

package/Source/Shaders/BillboardCollectionFS.glsl

@@ -131,7 +131,9 @@ void doThreePointDepthTest(float eyeDepth, bool applyTranslate) {
 }
 #endif
 
-void doDepthTest() {
+// Extra manual depth testing is done to allow more control over how a billboard is occluded 
+// by the globe when near and far from the camera.
+void doDepthTest(float globeDepth) {
     float temp = v_compressed.y;
     temp = temp * SHIFT_RIGHT1;
     float temp2 = (temp - floor(temp)) * SHIFT_LEFT1;
@@ -156,14 +158,10 @@ void doDepthTest() {
     }
 #endif
 
-    // Automatic depth testing of billboards is disabled (@see BillboardCollection#update).
-    // Instead, we do one of two types of manual depth tests (potentially in addition to the test above), depending on the camera's distance to the billboard fragment.
     // If we're far away, we just compare against a flat, camera-facing depth-plane at the ellipsoid's center.
     // If we're close, we compare against the globe depth texture (which includes depth from the 3D tile pass).
-    vec2 fragSt = gl_FragCoord.xy / czm_viewport.zw;
-    float globeDepth = getGlobeDepthAtCoords(fragSt);
-    if (globeDepth == 0.0) return; // Not on globe
-    
+
+    if (globeDepth == 0.0) return; // Not on globe    
     float distanceToEllipsoidCenter = -length(czm_viewerPositionWC); // depth is negative by convention
     float testDistance = (eyeDepth > -u_coarseDepthTestDistance) ? globeDepth : distanceToEllipsoidCenter;
     if (eyeDepth < testDistance) {
@@ -175,7 +173,10 @@ void main()
 {
     if (v_splitDirection < 0.0 && gl_FragCoord.x > czm_splitPosition) discard;
     if (v_splitDirection > 0.0 && gl_FragCoord.x < czm_splitPosition) discard;
-    doDepthTest();
+    
+    vec2 fragSt = gl_FragCoord.xy / czm_viewport.zw;
+    float globeDepth = getGlobeDepthAtCoords(fragSt);
+    doDepthTest(globeDepth);
     
     vec4 color = texture(u_atlas, v_textureCoordinates);
 
@@ -243,6 +244,18 @@ void main()
     out_FragColor = color;
 
 #ifdef LOG_DEPTH
-    czm_writeLogDepth();
+    // If we've made it here, we passed our manual depth test, above. But the automatic depth test will
+    // still run, and some fragments of the billboard may clip against the globe. To prevent that,
+    // ensure the depth value we write out is in front of the globe depth.
+    float depthArg = v_depthFromNearPlusOne;
+
+    if (globeDepth != 0.0) { // On the globe
+        float globeDepthFromNearPlusOne = (-globeDepth - czm_currentFrustum.x) + 1.0;
+        float nudge = max(globeDepthFromNearPlusOne * 5e-6, czm_epsilon7);
+        float globeOnTop = max(1.0, globeDepthFromNearPlusOne - nudge);
+        depthArg = min(depthArg, globeOnTop);
+    }
+
+    czm_writeLogDepth(depthArg);
 #endif
 }

package/Source/Shaders/BillboardCollectionFS.js

@@ -132,7 +132,9 @@ void doThreePointDepthTest(float eyeDepth, bool applyTranslate) {\n\
 }\n\
 #endif\n\
 \n\
-void doDepthTest() {\n\
+// Extra manual depth testing is done to allow more control over how a billboard is occluded \n\
+// by the globe when near and far from the camera.\n\
+void doDepthTest(float globeDepth) {\n\
     float temp = v_compressed.y;\n\
     temp = temp * SHIFT_RIGHT1;\n\
     float temp2 = (temp - floor(temp)) * SHIFT_LEFT1;\n\
@@ -157,14 +159,10 @@ void doDepthTest() {\n\
     }\n\
 #endif\n\
 \n\
-    // Automatic depth testing of billboards is disabled (@see BillboardCollection#update).\n\
-    // Instead, we do one of two types of manual depth tests (potentially in addition to the test above), depending on the camera's distance to the billboard fragment.\n\
     // If we're far away, we just compare against a flat, camera-facing depth-plane at the ellipsoid's center.\n\
     // If we're close, we compare against the globe depth texture (which includes depth from the 3D tile pass).\n\
-    vec2 fragSt = gl_FragCoord.xy / czm_viewport.zw;\n\
-    float globeDepth = getGlobeDepthAtCoords(fragSt);\n\
-    if (globeDepth == 0.0) return; // Not on globe\n\
-    \n\
+\n\
+    if (globeDepth == 0.0) return; // Not on globe    \n\
     float distanceToEllipsoidCenter = -length(czm_viewerPositionWC); // depth is negative by convention\n\
     float testDistance = (eyeDepth > -u_coarseDepthTestDistance) ? globeDepth : distanceToEllipsoidCenter;\n\
     if (eyeDepth < testDistance) {\n\
@@ -176,7 +174,10 @@ void main()\n\
 {\n\
     if (v_splitDirection < 0.0 && gl_FragCoord.x > czm_splitPosition) discard;\n\
     if (v_splitDirection > 0.0 && gl_FragCoord.x < czm_splitPosition) discard;\n\
-    doDepthTest();\n\
+    \n\
+    vec2 fragSt = gl_FragCoord.xy / czm_viewport.zw;\n\
+    float globeDepth = getGlobeDepthAtCoords(fragSt);\n\
+    doDepthTest(globeDepth);\n\
     \n\
     vec4 color = texture(u_atlas, v_textureCoordinates);\n\
 \n\
@@ -244,6 +245,18 @@ void main()\n\
     out_FragColor = color;\n\
 \n\
 #ifdef LOG_DEPTH\n\
-    czm_writeLogDepth();\n\
+    // If we've made it here, we passed our manual depth test, above. But the automatic depth test will\n\
+    // still run, and some fragments of the billboard may clip against the globe. To prevent that,\n\
+    // ensure the depth value we write out is in front of the globe depth.\n\
+    float depthArg = v_depthFromNearPlusOne;\n\
+\n\
+    if (globeDepth != 0.0) { // On the globe\n\
+        float globeDepthFromNearPlusOne = (-globeDepth - czm_currentFrustum.x) + 1.0;\n\
+        float nudge = max(globeDepthFromNearPlusOne * 5e-6, czm_epsilon7);\n\
+        float globeOnTop = max(1.0, globeDepthFromNearPlusOne - nudge);\n\
+        depthArg = min(depthArg, globeOnTop);\n\
+    }\n\
+\n\
+    czm_writeLogDepth(depthArg);\n\
 #endif\n\
 }";