@cesium/engine 22.3.0 → 23.0.0

package/Source/Scene/parseStructuralMetadata.js

@@ -6,6 +6,18 @@ import PropertyTexture from "./PropertyTexture.js";
 import PropertyAttribute from "./PropertyAttribute.js";
 import StructuralMetadata from "./StructuralMetadata.js";
 import MetadataTable from "./MetadataTable.js";
+import Sampler from "../Renderer/Sampler.js";
+import Texture from "../Renderer/Texture.js";
+import PixelFormat from "../Core/PixelFormat.js";
+import PixelDatatype from "../Renderer/PixelDatatype.js";
+import RuntimeError from "../Core/RuntimeError.js";
+import oneTimeWarning from "../Core/oneTimeWarning.js";
+import TextureWrap from "../Renderer/TextureWrap.js";
+import TextureMagnificationFilter from "../Renderer/TextureMagnificationFilter.js";
+import TextureMinificationFilter from "../Renderer/TextureMinificationFilter.js";
+import ContextLimits from "../Renderer/ContextLimits.js";
+import MetadataComponentType from "./MetadataComponentType.js";
+import MetadataType from "./MetadataType.js";
 
 /**
  * Parse the <code>EXT_structural_metadata</code> glTF extension to create a
@@ -16,6 +28,7 @@ import MetadataTable from "./MetadataTable.js";
  * @param {MetadataSchema} options.schema The parsed schema.
  * @param {Object<string, Uint8Array>} [options.bufferViews] An object mapping bufferView IDs to Uint8Array objects.
  * @param {Object<string, Texture>} [options.textures] An object mapping texture IDs to {@link Texture} objects.
+ * @param {Context} [options.context] The current rendering context.
  * @return {StructuralMetadata} A structural metadata object
  * @private
  * @experimental This feature is using part of the 3D Tiles spec that is not final and is subject to change without Cesium's standard deprecation policy.
@@ -38,12 +51,20 @@ function parseStructuralMetadata(options) {
     for (let i = 0; i < extension.propertyTables.length; i++) {
       const propertyTable = extension.propertyTables[i];
       const classDefinition = schema.classes[propertyTable.class];
+      const propertyTableTexture = createTextureForPropertyTable(
+        propertyTable,
+        options.bufferViews,
+        classDefinition,
+        options.context,
+      );
+
       const metadataTable = new MetadataTable({
         count: propertyTable.count,
         properties: propertyTable.properties,
         class: classDefinition,
         bufferViews: options.bufferViews,
       });
+
       propertyTables.push(
         new PropertyTable({
           id: i,
@@ -52,6 +73,7 @@ function parseStructuralMetadata(options) {
           metadataTable: metadataTable,
           extras: propertyTable.extras,
           extensions: propertyTable.extensions,
+          texture: propertyTableTexture,
         }),
       );
     }
@@ -99,4 +121,226 @@ function parseStructuralMetadata(options) {
   });
 }
 
+// Always use four channels for property table textures.
+const NUM_CHANNELS = 4;
+
+/**
+ * Creates a texture from a set of property table properties (those which are GPU compatible).
+ * Each row of the texture is a property, with each column corresponding to a given feature.
+ *
+ * @param {PropertyTable} propertyTable The property table.
+ * @param {Object<string, Uint8Array>} bufferViews An object mapping bufferView IDs to Uint8Array objects for the given property table.
+ * @param {MetadataClass} classDefinition Class defined in the schema
+ * @param {Context} context The rendering context.
+ * @returns {Texture|undefined} The created texture, or <code>undefined</code> if no properties are GPU compatible.
+ *
+ * @private
+ */
+function createTextureForPropertyTable(
+  propertyTable,
+  bufferViews,
+  classDefinition,
+  context,
+) {
+  const properties = propertyTable.properties;
+  if (!defined(properties)) {
+    return undefined;
+  }
+
+  const numFeatures = propertyTable.count;
+
+  let gpuCompatiblePropertyBufferViews;
+  try {
+    gpuCompatiblePropertyBufferViews = collectGpuCompatiblePropertyBufferViews(
+      properties,
+      bufferViews,
+      classDefinition,
+      numFeatures,
+    );
+  } catch (error) {
+    console.warn(
+      `Failed to create texture for property table "${propertyTable.name}": ${error.message}`,
+    );
+    return undefined;
+  }
+
+  const numGpuCompatibleProperties = gpuCompatiblePropertyBufferViews.length;
+
+  if (numGpuCompatibleProperties === 0) {
+    return undefined;
+  }
+
+  // In the future, we could use multiple textures if we would exceed the maximum texture size.
+  if (
+    numFeatures > ContextLimits.maximumTextureSize ||
+    numGpuCompatibleProperties > ContextLimits.maximumTextureSize
+  ) {
+    oneTimeWarning(
+      "PropertyTableTextureExceedsMaximumSize",
+      `Cannot create a texture for the property table "${propertyTable.name}" because it exceeds the maximum texture size of ${ContextLimits.maximumTextureSize}.`,
+    );
+    return undefined;
+  }
+
+  const packedBufferView = packPropertyTablePropertiesIntoRGBA8(
+    gpuCompatiblePropertyBufferViews,
+    numFeatures,
+  );
+
+  // Create a sampler fit for sampling raw data without mipmapping / filtering etc.
+  const sampler = new Sampler({
+    wrapS: TextureWrap.CLAMP_TO_EDGE,
+    wrapT: TextureWrap.CLAMP_TO_EDGE,
+    minificationFilter: TextureMinificationFilter.NEAREST,
+    magnificationFilter: TextureMagnificationFilter.NEAREST,
+  });
+
+  return Texture.create({
+    context: context,
+    pixelFormat: PixelFormat.RGBA,
+    pixelDatatype: PixelDatatype.UNSIGNED_BYTE,
+    sampler: sampler,
+    flipY: false,
+    source: {
+      width: numFeatures,
+      height: numGpuCompatibleProperties,
+      arrayBufferView: packedBufferView,
+    },
+  });
+}
+
+function collectGpuCompatiblePropertyBufferViews(
+  properties,
+  bufferViews,
+  classDefinition,
+  numFeatures,
+) {
+  const bufferViewsForThisTable = [];
+  const classProperties = classDefinition.properties;
+
+  // It's possible for a primitive in a tileset to only use a subset of the class properties defined in the schema.
+  // For instance, the Design Tiler merges classes together by default, and omits properties in primitives that aren't used.
+  // To make the default values available to the GPU, and to avoid compiling different versions of the shader for each primitive,
+  // we iterate over _all_ class properties here - not just the properties in the property table.
+  for (const [propertyId, classProperty] of Object.entries(classProperties)) {
+    // Certain properties like strings, dynamic-sized arrays, and 64-bit types cannot be represented natively on the GPU.
+    if (!classProperty.isGpuCompatible(NUM_CHANNELS)) {
+      continue;
+    }
+
+    const property = properties[propertyId];
+    const bufferView = defined(property)
+      ? bufferViews[property.values]
+      : createNoDataBufferView(classProperty, numFeatures);
+
+    const bufferViewLength = bufferView.length;
+    const bytesPerElement = classProperty.bytesPerElement();
+    const numBufferElements = bufferViewLength / bytesPerElement;
+    if (numBufferElements !== numFeatures) {
+      throw new RuntimeError(
+        `Property with ID: "${propertyId}" has (${numBufferElements}), which does not match number of features in the property table: (${numFeatures}).`,
+      );
+    }
+
+    bufferViewsForThisTable.push({
+      view: bufferView,
+      bytesPerElement: bytesPerElement,
+    });
+  }
+
+  return bufferViewsForThisTable;
+}
+
+/**
+ * When a property is part of a tileset class schema but not used in a property table,
+ * we create a buffer view filled with the property's noData value.
+ *
+ * @param {MetadataClassProperty} classProperty The class property definition.
+ * @param {number} numFeatures The number of features in the property table.
+ *
+ * @returns {Uint8Array} A buffer view filled with the property's noData value.
+ *
+ * @private
+ */
+function createNoDataBufferView(classProperty, numFeatures) {
+  // noData can be a number, an array of numbers (e.g. for vecN types), or a nested array of numbers (e.g. for arrays of vecN types).
+  let noData = classProperty.noData;
+  const metadataComponentCount = MetadataType.getComponentCount(
+    classProperty.type,
+  );
+  const metadataArrayLength = classProperty.isArray
+    ? classProperty.arrayLength
+    : 1;
+
+  // Special case: noData enum values are specified as strings, so we need to convert them to numbers here.
+  if (classProperty.type === MetadataType.ENUM) {
+    const enumDefinition = classProperty.enumType;
+    noData = enumDefinition.valuesByName[noData];
+  }
+
+  // Wrap noData in an array (up to two times) so we can treat it uniformly in the loop below.
+  if (metadataComponentCount === 1) {
+    noData = [noData];
+  }
+
+  if (metadataArrayLength === 1) {
+    noData = [noData];
+  }
+
+  const bytesPerElement = classProperty.bytesPerElement();
+  const buffer = new ArrayBuffer(bytesPerElement * numFeatures);
+  const view = new DataView(buffer);
+  const setter = MetadataComponentType.getDataViewSetter(
+    view,
+    classProperty.componentType,
+  );
+
+  for (let i = 0; i < numFeatures; i++) {
+    for (let j = 0; j < metadataArrayLength; j++) {
+      for (let k = 0; k < metadataComponentCount; k++) {
+        setter(bytesPerElement * i + j + k, noData[j][k]);
+      }
+    }
+  }
+
+  return new Uint8Array(buffer);
+}
+
+// Make one big buffer view to load into the texture
+// Since each texel is always 4 bytes (RGBA8 format), elements less than 4 bytes need to be padded (respecting little-endian order).
+function packPropertyTablePropertiesIntoRGBA8(
+  bufferViewsForThisTable,
+  numFeatures,
+) {
+  const numGpuCompatibleProperties = bufferViewsForThisTable.length;
+  const packedBufferView = new Uint8Array(
+    numGpuCompatibleProperties * numFeatures * NUM_CHANNELS,
+  );
+
+  for (let i = 0, offset = 0; i < bufferViewsForThisTable.length; i++) {
+    const bufferView = bufferViewsForThisTable[i].view;
+    const bytesPerElement = bufferViewsForThisTable[i].bytesPerElement;
+    const numElements = bufferView.length / bytesPerElement;
+
+    for (let j = 0; j < numElements; j++) {
+      const sourceOffset = j * bytesPerElement;
+      const destOffset = offset + j * NUM_CHANNELS;
+
+      packedBufferView.set(
+        bufferView.subarray(sourceOffset, sourceOffset + bytesPerElement),
+        destOffset,
+      );
+
+      // Pad remaining channels with 0
+      for (let k = bytesPerElement; k < NUM_CHANNELS; k++) {
+        packedBufferView[destOffset + k] = 0;
+      }
+    }
+
+    offset += numElements * NUM_CHANNELS;
+  }
+
+  return packedBufferView;
+}
+
 export default parseStructuralMetadata;

package/Source/Shaders/BillboardCollectionFS.glsl

@@ -9,7 +9,7 @@ uniform vec4 u_highlightColor;
 in vec2 v_textureCoordinates;
 in vec4 v_pickColor;
 in vec4 v_color;
-in float v_splitDirection;
+flat in vec2 v_splitDirectionAndEllipsoidDepthEC;
 
 #ifdef SDF
 in vec4 v_outlineColor;
@@ -126,28 +126,39 @@ void doThreePointDepthTest(float eyeDepth, bool applyTranslate) {
     float globeDepth3 = getGlobeDepth(adjustedST, vec2(1.0, 1.0), applyTranslate, dimensions, imageSize); // top right corner
     if (globeDepth3 == 0.0 || globeDepth3 < epsilonEyeDepth) return;
 
-    // All three key points are occluded, discard the fragment (and by extension the entire billboard)            
+    // All three key points are occluded, discard the fragment (and by extension the entire billboard)
     discard;
 }
 #endif
 
-// 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) {
+bool getDepthTestEnabled() {
     float temp = v_compressed.y;
     temp = temp * SHIFT_RIGHT1;
     float temp2 = (temp - floor(temp)) * SHIFT_LEFT1;
-    bool enableDepthCheck = temp2 != 0.0;
-    if (!enableDepthCheck) return;
+    return temp2 != 0.0;
+}
+
+float getRelativeEyeDepth(float eyeDepth, float distanceToEllipsoid, float epsilon) {
+    float depthDifferential = eyeDepth - distanceToEllipsoid;
+    float depthRatio = abs(depthDifferential / distanceToEllipsoid);
+    if (depthRatio < epsilon) {
+        // The approximations are imprecise, so use an epsilon check for small value differences and assume a value of 0.0
+        return 0.0;
+    }
+
+    return depthDifferential;
+}
 
-    float eyeDepth = v_compressed.x;
+// 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 eyeDepth, float globeDepth) {
 
 #ifdef FS_THREE_POINT_DEPTH_CHECK
     // If the billboard is clamped to the ground and within a given distance, we do a 3-point depth test. This test is performed in the vertex shader, unless
     // vertex texture sampling is not supported, in which case we do it here.
     bool applyTranslate = floor(temp) != 0.0;
     doThreePointDepthTest(eyeDepth, applyTranslate);
-    
+
 #elif defined(VS_THREE_POINT_DEPTH_CHECK)
     // Since discarding vertices is not possible, the vertex shader sets eyeDepth to 0 to indicate the depth test failed. Apply the discard here.
     if (eyeDepth > -u_threePointDepthTestDistance) {
@@ -157,27 +168,58 @@ void doDepthTest(float globeDepth) {
         return;
     }
 #endif
+    bool useGlobeDepth = eyeDepth > -u_coarseDepthTestDistance;
+    if (useGlobeDepth && globeDepth == 0.0) {
+        // Pixel is not on the globe, so there is no distance to compare against. Pass.
+        return;
+    }
 
-    // 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).
-
-    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) {
+    // If the camera is close, compare against the globe depth texture that includes depth from the 3D tile pass.
+    if (useGlobeDepth && getRelativeEyeDepth(eyeDepth, globeDepth, czm_epsilon1) < 0.0) {
         discard;
     }
 }
 
+#ifdef LOG_DEPTH
+void writeDepth(float eyeDepth, float globeDepth, float distanceToEllipsoid) {
+    // If we've made it here, the manual depth test above determined that this fragment should be visible.
+    // But the automatic depth test must still run in order to write the result to the depth buffer, and its results may
+    // disagree with our manual depth test's results. To prefer our manual results when in front of the globe, apply an offset towards the camera.
+
+    float depthArg = v_depthFromNearPlusOne;
+
+    if (globeDepth != 0.0 && getRelativeEyeDepth(eyeDepth, distanceToEllipsoid, czm_epsilon3) > 0.0) { 
+        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
+
 void main()
 {
-    if (v_splitDirection < 0.0 && gl_FragCoord.x > czm_splitPosition) discard;
-    if (v_splitDirection > 0.0 && gl_FragCoord.x < czm_splitPosition) discard;
-    
-    vec2 fragSt = gl_FragCoord.xy / czm_viewport.zw;
-    float globeDepth = getGlobeDepthAtCoords(fragSt);
-    doDepthTest(globeDepth);
-    
+    if (v_splitDirectionAndEllipsoidDepthEC.x < 0.0 && gl_FragCoord.x > czm_splitPosition) {
+        discard;
+    }
+    if (v_splitDirectionAndEllipsoidDepthEC.x > 0.0 && gl_FragCoord.x < czm_splitPosition) {
+        discard;
+    }
+
+    if (getDepthTestEnabled()) {
+        vec2 fragSt = gl_FragCoord.xy / czm_viewport.zw;
+        float eyeDepth = v_compressed.x;
+        float globeDepth = getGlobeDepthAtCoords(fragSt);
+        float distanceToEllipsoid = -v_splitDirectionAndEllipsoidDepthEC.y;
+        doDepthTest(eyeDepth, globeDepth);
+
+        #ifdef LOG_DEPTH
+        writeDepth(eyeDepth, globeDepth, distanceToEllipsoid);
+        #endif
+    }
+
     vec4 color = texture(u_atlas, v_textureCoordinates);
 
 #ifdef SDF
@@ -242,20 +284,4 @@ void main()
     color *= u_highlightColor;
 #endif
     out_FragColor = color;
-
-#ifdef LOG_DEPTH
-    // 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

@@ -10,7 +10,7 @@ uniform vec4 u_highlightColor;\n\
 in vec2 v_textureCoordinates;\n\
 in vec4 v_pickColor;\n\
 in vec4 v_color;\n\
-in float v_splitDirection;\n\
+flat in vec2 v_splitDirectionAndEllipsoidDepthEC;\n\
 \n\
 #ifdef SDF\n\
 in vec4 v_outlineColor;\n\
@@ -127,28 +127,39 @@ void doThreePointDepthTest(float eyeDepth, bool applyTranslate) {\n\
     float globeDepth3 = getGlobeDepth(adjustedST, vec2(1.0, 1.0), applyTranslate, dimensions, imageSize); // top right corner\n\
     if (globeDepth3 == 0.0 || globeDepth3 < epsilonEyeDepth) return;\n\
 \n\
-    // All three key points are occluded, discard the fragment (and by extension the entire billboard)            \n\
+    // All three key points are occluded, discard the fragment (and by extension the entire billboard)\n\
     discard;\n\
 }\n\
 #endif\n\
 \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\
+bool getDepthTestEnabled() {\n\
     float temp = v_compressed.y;\n\
     temp = temp * SHIFT_RIGHT1;\n\
     float temp2 = (temp - floor(temp)) * SHIFT_LEFT1;\n\
-    bool enableDepthCheck = temp2 != 0.0;\n\
-    if (!enableDepthCheck) return;\n\
+    return temp2 != 0.0;\n\
+}\n\
+\n\
+float getRelativeEyeDepth(float eyeDepth, float distanceToEllipsoid, float epsilon) {\n\
+    float depthDifferential = eyeDepth - distanceToEllipsoid;\n\
+    float depthRatio = abs(depthDifferential / distanceToEllipsoid);\n\
+    if (depthRatio < epsilon) {\n\
+        // The approximations are imprecise, so use an epsilon check for small value differences and assume a value of 0.0\n\
+        return 0.0;\n\
+    }\n\
+\n\
+    return depthDifferential;\n\
+}\n\
 \n\
-    float eyeDepth = v_compressed.x;\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 eyeDepth, float globeDepth) {\n\
 \n\
 #ifdef FS_THREE_POINT_DEPTH_CHECK\n\
     // If the billboard is clamped to the ground and within a given distance, we do a 3-point depth test. This test is performed in the vertex shader, unless\n\
     // vertex texture sampling is not supported, in which case we do it here.\n\
     bool applyTranslate = floor(temp) != 0.0;\n\
     doThreePointDepthTest(eyeDepth, applyTranslate);\n\
-    \n\
+\n\
 #elif defined(VS_THREE_POINT_DEPTH_CHECK)\n\
     // Since discarding vertices is not possible, the vertex shader sets eyeDepth to 0 to indicate the depth test failed. Apply the discard here.\n\
     if (eyeDepth > -u_threePointDepthTestDistance) {\n\
@@ -158,27 +169,58 @@ void doDepthTest(float globeDepth) {\n\
         return;\n\
     }\n\
 #endif\n\
+    bool useGlobeDepth = eyeDepth > -u_coarseDepthTestDistance;\n\
+    if (useGlobeDepth && globeDepth == 0.0) {\n\
+        // Pixel is not on the globe, so there is no distance to compare against. Pass.\n\
+        return;\n\
+    }\n\
 \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\
-\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\
+    // If the camera is close, compare against the globe depth texture that includes depth from the 3D tile pass.\n\
+    if (useGlobeDepth && getRelativeEyeDepth(eyeDepth, globeDepth, czm_epsilon1) < 0.0) {\n\
         discard;\n\
     }\n\
 }\n\
 \n\
+#ifdef LOG_DEPTH\n\
+void writeDepth(float eyeDepth, float globeDepth, float distanceToEllipsoid) {\n\
+    // If we've made it here, the manual depth test above determined that this fragment should be visible.\n\
+    // But the automatic depth test must still run in order to write the result to the depth buffer, and its results may\n\
+    // disagree with our manual depth test's results. To prefer our manual results when in front of the globe, apply an offset towards the camera.\n\
+\n\
+    float depthArg = v_depthFromNearPlusOne;\n\
+\n\
+    if (globeDepth != 0.0 && getRelativeEyeDepth(eyeDepth, distanceToEllipsoid, czm_epsilon3) > 0.0) { \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\
+}\n\
+#endif\n\
+\n\
 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\
-    \n\
-    vec2 fragSt = gl_FragCoord.xy / czm_viewport.zw;\n\
-    float globeDepth = getGlobeDepthAtCoords(fragSt);\n\
-    doDepthTest(globeDepth);\n\
-    \n\
+    if (v_splitDirectionAndEllipsoidDepthEC.x < 0.0 && gl_FragCoord.x > czm_splitPosition) {\n\
+        discard;\n\
+    }\n\
+    if (v_splitDirectionAndEllipsoidDepthEC.x > 0.0 && gl_FragCoord.x < czm_splitPosition) {\n\
+        discard;\n\
+    }\n\
+\n\
+    if (getDepthTestEnabled()) {\n\
+        vec2 fragSt = gl_FragCoord.xy / czm_viewport.zw;\n\
+        float eyeDepth = v_compressed.x;\n\
+        float globeDepth = getGlobeDepthAtCoords(fragSt);\n\
+        float distanceToEllipsoid = -v_splitDirectionAndEllipsoidDepthEC.y;\n\
+        doDepthTest(eyeDepth, globeDepth);\n\
+\n\
+        #ifdef LOG_DEPTH\n\
+        writeDepth(eyeDepth, globeDepth, distanceToEllipsoid);\n\
+        #endif\n\
+    }\n\
+\n\
     vec4 color = texture(u_atlas, v_textureCoordinates);\n\
 \n\
 #ifdef SDF\n\
@@ -243,20 +285,5 @@ void main()\n\
     color *= u_highlightColor;\n\
 #endif\n\
     out_FragColor = color;\n\
-\n\
-#ifdef LOG_DEPTH\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\
-}";
+}\n\
+";