@cesium/engine 21.0.1 → 22.1.0

package/Source/Shaders/BillboardCollectionFS.glsl

@@ -1,4 +1,6 @@
 uniform sampler2D u_atlas;
+uniform float u_coarseDepthTestDistance;
+uniform float u_threePointDepthTestDistance;
 
 #ifdef VECTOR_TILE
 uniform vec4 u_highlightColor;
@@ -14,18 +16,33 @@ in vec4 v_outlineColor;
 in float v_outlineWidth;
 #endif
 
-#ifdef FRAGMENT_DEPTH_CHECK
+in vec4 v_compressed;                               // x: eyeDepth, y: applyTranslate & enableDepthCheck, z: dimensions, w: imageSize
+const float SHIFT_LEFT1 = 2.0;
+const float SHIFT_RIGHT1 = 1.0 / 2.0;
+
+#ifdef FS_THREE_POINT_DEPTH_CHECK
 in vec4 v_textureCoordinateBounds;                  // the min and max x and y values for the texture coordinates
 in vec4 v_originTextureCoordinateAndTranslate;      // texture coordinate at the origin, billboard translate (used for label glyphs)
-in vec4 v_compressed;                               // x: eyeDepth, y: applyTranslate & enableDepthCheck, z: dimensions, w: imageSize
 in mat2 v_rotationMatrix;
 
 const float SHIFT_LEFT12 = 4096.0;
-const float SHIFT_LEFT1 = 2.0;
 
 const float SHIFT_RIGHT12 = 1.0 / 4096.0;
-const float SHIFT_RIGHT1 = 1.0 / 2.0;
+#endif
+
+float getGlobeDepthAtCoords(vec2 st)
+{
+    float logDepthOrDepth = czm_unpackDepth(texture(czm_globeDepthTexture, st));
+    if (logDepthOrDepth == 0.0)
+    {
+        return 0.0; // not on the globe
+    }
+
+    vec4 eyeCoordinate = czm_windowToEyeCoordinates(gl_FragCoord.xy, logDepthOrDepth);
+    return eyeCoordinate.z / eyeCoordinate.w;
+}
 
+#ifdef FS_THREE_POINT_DEPTH_CHECK
 float getGlobeDepth(vec2 adjustedST, vec2 depthLookupST, bool applyTranslate, vec2 dimensions, vec2 imageSize)
 {
     vec2 lookupVector = imageSize * (depthLookupST - adjustedST);
@@ -42,19 +59,10 @@ float getGlobeDepth(vec2 adjustedST, vec2 depthLookupST, bool applyTranslate, ve
     }
 
     vec2 st = ((lookupVector - translation + labelOffset) + gl_FragCoord.xy) / czm_viewport.zw;
-    float logDepthOrDepth = czm_unpackDepth(texture(czm_globeDepthTexture, st));
-
-    if (logDepthOrDepth == 0.0)
-    {
-        return 0.0; // not on the globe
-    }
-
-    vec4 eyeCoordinate = czm_windowToEyeCoordinates(gl_FragCoord.xy, logDepthOrDepth);
-    return eyeCoordinate.z / eyeCoordinate.w;
+    return getGlobeDepthAtCoords(st);
 }
 #endif
 
-
 #ifdef SDF
 
 // Get the distance from the edge of a glyph at a given position sampling an SDF texture.
@@ -85,11 +93,91 @@ vec4 getSDFColor(vec2 position, float outlineWidth, vec4 outlineColor, float smo
 }
 #endif
 
+#ifdef FS_THREE_POINT_DEPTH_CHECK
+void doThreePointDepthTest(float eyeDepth, bool applyTranslate) {
+
+    if (eyeDepth < -u_threePointDepthTestDistance) return;
+    float temp = v_compressed.z;
+    temp = temp * SHIFT_RIGHT12;
+
+    vec2 dimensions;
+    dimensions.y = (temp - floor(temp)) * SHIFT_LEFT12;
+    dimensions.x = floor(temp);
+
+    temp = v_compressed.w;
+    temp = temp * SHIFT_RIGHT12;
+
+    vec2 imageSize;
+    imageSize.y = (temp - floor(temp)) * SHIFT_LEFT12;
+    imageSize.x = floor(temp);
+
+    vec2 adjustedST = v_textureCoordinates - v_textureCoordinateBounds.xy;
+    adjustedST = adjustedST / vec2(v_textureCoordinateBounds.z - v_textureCoordinateBounds.x, v_textureCoordinateBounds.w - v_textureCoordinateBounds.y);
+
+    float epsilonEyeDepth = v_compressed.x + czm_epsilon1;
+    float globeDepth1 = getGlobeDepth(adjustedST, v_originTextureCoordinateAndTranslate.xy, applyTranslate, dimensions, imageSize);
+
+    // negative values go into the screen
+    if (globeDepth1 == 0.0 || globeDepth1 < epsilonEyeDepth) return;
+
+    float globeDepth2 = getGlobeDepth(adjustedST, vec2(0.0, 1.0), applyTranslate, dimensions, imageSize); // top left corner
+    if (globeDepth2 == 0.0 || globeDepth2 < epsilonEyeDepth) return;
+
+    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)            
+    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) {
+    float temp = v_compressed.y;
+    temp = temp * SHIFT_RIGHT1;
+    float temp2 = (temp - floor(temp)) * SHIFT_LEFT1;
+    bool enableDepthCheck = temp2 != 0.0;
+    if (!enableDepthCheck) return;
+
+    float eyeDepth = v_compressed.x;
+
+#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) {
+        if (eyeDepth == 0.0) {
+            discard;
+        }
+        return;
+    }
+#endif
+
+    // 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) {
+        discard;
+    }
+}
+
 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);
+    
     vec4 color = texture(u_atlas, v_textureCoordinates);
 
 #ifdef SDF
@@ -156,53 +244,18 @@ void main()
     out_FragColor = color;
 
 #ifdef LOG_DEPTH
-    czm_writeLogDepth();
-#endif
-
-#ifdef FRAGMENT_DEPTH_CHECK
-    float temp = v_compressed.y;
-
-    temp = temp * SHIFT_RIGHT1;
-
-    float temp2 = (temp - floor(temp)) * SHIFT_LEFT1;
-    bool enableDepthTest = temp2 != 0.0;
-    bool applyTranslate = floor(temp) != 0.0;
-
-    if (enableDepthTest) {
-        temp = v_compressed.z;
-        temp = temp * SHIFT_RIGHT12;
-
-        vec2 dimensions;
-        dimensions.y = (temp - floor(temp)) * SHIFT_LEFT12;
-        dimensions.x = floor(temp);
-
-        temp = v_compressed.w;
-        temp = temp * SHIFT_RIGHT12;
-
-        vec2 imageSize;
-        imageSize.y = (temp - floor(temp)) * SHIFT_LEFT12;
-        imageSize.x = floor(temp);
-
-        vec2 adjustedST = v_textureCoordinates - v_textureCoordinateBounds.xy;
-        adjustedST = adjustedST / vec2(v_textureCoordinateBounds.z - v_textureCoordinateBounds.x, v_textureCoordinateBounds.w - v_textureCoordinateBounds.y);
-
-        float epsilonEyeDepth = v_compressed.x + czm_epsilon1;
-        float globeDepth1 = getGlobeDepth(adjustedST, v_originTextureCoordinateAndTranslate.xy, applyTranslate, dimensions, imageSize);
-
-        // negative values go into the screen
-        if (globeDepth1 != 0.0 && globeDepth1 > epsilonEyeDepth)
-        {
-            float globeDepth2 = getGlobeDepth(adjustedST, vec2(0.0, 1.0), applyTranslate, dimensions, imageSize); // top left corner
-            if (globeDepth2 != 0.0 && globeDepth2 > epsilonEyeDepth)
-            {
-                float globeDepth3 = getGlobeDepth(adjustedST, vec2(1.0, 1.0), applyTranslate, dimensions, imageSize); // top right corner
-                if (globeDepth3 != 0.0 && globeDepth3 > epsilonEyeDepth)
-                {
-                    discard;
-                }
-            }
-        }
+    // 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);
     }
-#endif
 
-}
+    czm_writeLogDepth(depthArg);
+#endif
+}

package/Source/Shaders/BillboardCollectionFS.js

@@ -1,5 +1,7 @@
 //This file is automatically rebuilt by the Cesium build process.
 export default "uniform sampler2D u_atlas;\n\
+uniform float u_coarseDepthTestDistance;\n\
+uniform float u_threePointDepthTestDistance;\n\
 \n\
 #ifdef VECTOR_TILE\n\
 uniform vec4 u_highlightColor;\n\
@@ -15,18 +17,33 @@ in vec4 v_outlineColor;\n\
 in float v_outlineWidth;\n\
 #endif\n\
 \n\
-#ifdef FRAGMENT_DEPTH_CHECK\n\
+in vec4 v_compressed;                               // x: eyeDepth, y: applyTranslate & enableDepthCheck, z: dimensions, w: imageSize\n\
+const float SHIFT_LEFT1 = 2.0;\n\
+const float SHIFT_RIGHT1 = 1.0 / 2.0;\n\
+\n\
+#ifdef FS_THREE_POINT_DEPTH_CHECK\n\
 in vec4 v_textureCoordinateBounds;                  // the min and max x and y values for the texture coordinates\n\
 in vec4 v_originTextureCoordinateAndTranslate;      // texture coordinate at the origin, billboard translate (used for label glyphs)\n\
-in vec4 v_compressed;                               // x: eyeDepth, y: applyTranslate & enableDepthCheck, z: dimensions, w: imageSize\n\
 in mat2 v_rotationMatrix;\n\
 \n\
 const float SHIFT_LEFT12 = 4096.0;\n\
-const float SHIFT_LEFT1 = 2.0;\n\
 \n\
 const float SHIFT_RIGHT12 = 1.0 / 4096.0;\n\
-const float SHIFT_RIGHT1 = 1.0 / 2.0;\n\
+#endif\n\
+\n\
+float getGlobeDepthAtCoords(vec2 st)\n\
+{\n\
+    float logDepthOrDepth = czm_unpackDepth(texture(czm_globeDepthTexture, st));\n\
+    if (logDepthOrDepth == 0.0)\n\
+    {\n\
+        return 0.0; // not on the globe\n\
+    }\n\
+\n\
+    vec4 eyeCoordinate = czm_windowToEyeCoordinates(gl_FragCoord.xy, logDepthOrDepth);\n\
+    return eyeCoordinate.z / eyeCoordinate.w;\n\
+}\n\
 \n\
+#ifdef FS_THREE_POINT_DEPTH_CHECK\n\
 float getGlobeDepth(vec2 adjustedST, vec2 depthLookupST, bool applyTranslate, vec2 dimensions, vec2 imageSize)\n\
 {\n\
     vec2 lookupVector = imageSize * (depthLookupST - adjustedST);\n\
@@ -43,19 +60,10 @@ float getGlobeDepth(vec2 adjustedST, vec2 depthLookupST, bool applyTranslate, ve
     }\n\
 \n\
     vec2 st = ((lookupVector - translation + labelOffset) + gl_FragCoord.xy) / czm_viewport.zw;\n\
-    float logDepthOrDepth = czm_unpackDepth(texture(czm_globeDepthTexture, st));\n\
-\n\
-    if (logDepthOrDepth == 0.0)\n\
-    {\n\
-        return 0.0; // not on the globe\n\
-    }\n\
-\n\
-    vec4 eyeCoordinate = czm_windowToEyeCoordinates(gl_FragCoord.xy, logDepthOrDepth);\n\
-    return eyeCoordinate.z / eyeCoordinate.w;\n\
+    return getGlobeDepthAtCoords(st);\n\
 }\n\
 #endif\n\
 \n\
-\n\
 #ifdef SDF\n\
 \n\
 // Get the distance from the edge of a glyph at a given position sampling an SDF texture.\n\
@@ -86,11 +94,91 @@ vec4 getSDFColor(vec2 position, float outlineWidth, vec4 outlineColor, float smo
 }\n\
 #endif\n\
 \n\
+#ifdef FS_THREE_POINT_DEPTH_CHECK\n\
+void doThreePointDepthTest(float eyeDepth, bool applyTranslate) {\n\
+\n\
+    if (eyeDepth < -u_threePointDepthTestDistance) return;\n\
+    float temp = v_compressed.z;\n\
+    temp = temp * SHIFT_RIGHT12;\n\
+\n\
+    vec2 dimensions;\n\
+    dimensions.y = (temp - floor(temp)) * SHIFT_LEFT12;\n\
+    dimensions.x = floor(temp);\n\
+\n\
+    temp = v_compressed.w;\n\
+    temp = temp * SHIFT_RIGHT12;\n\
+\n\
+    vec2 imageSize;\n\
+    imageSize.y = (temp - floor(temp)) * SHIFT_LEFT12;\n\
+    imageSize.x = floor(temp);\n\
+\n\
+    vec2 adjustedST = v_textureCoordinates - v_textureCoordinateBounds.xy;\n\
+    adjustedST = adjustedST / vec2(v_textureCoordinateBounds.z - v_textureCoordinateBounds.x, v_textureCoordinateBounds.w - v_textureCoordinateBounds.y);\n\
+\n\
+    float epsilonEyeDepth = v_compressed.x + czm_epsilon1;\n\
+    float globeDepth1 = getGlobeDepth(adjustedST, v_originTextureCoordinateAndTranslate.xy, applyTranslate, dimensions, imageSize);\n\
+\n\
+    // negative values go into the screen\n\
+    if (globeDepth1 == 0.0 || globeDepth1 < epsilonEyeDepth) return;\n\
+\n\
+    float globeDepth2 = getGlobeDepth(adjustedST, vec2(0.0, 1.0), applyTranslate, dimensions, imageSize); // top left corner\n\
+    if (globeDepth2 == 0.0 || globeDepth2 < epsilonEyeDepth) return;\n\
+\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\
+    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\
+    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\
+\n\
+    float eyeDepth = v_compressed.x;\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\
+#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\
+        if (eyeDepth == 0.0) {\n\
+            discard;\n\
+        }\n\
+        return;\n\
+    }\n\
+#endif\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\
+        discard;\n\
+    }\n\
+}\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\
     vec4 color = texture(u_atlas, v_textureCoordinates);\n\
 \n\
 #ifdef SDF\n\
@@ -157,54 +245,18 @@ void main()\n\
     out_FragColor = color;\n\
 \n\
 #ifdef LOG_DEPTH\n\
-    czm_writeLogDepth();\n\
-#endif\n\
-\n\
-#ifdef FRAGMENT_DEPTH_CHECK\n\
-    float temp = v_compressed.y;\n\
-\n\
-    temp = temp * SHIFT_RIGHT1;\n\
-\n\
-    float temp2 = (temp - floor(temp)) * SHIFT_LEFT1;\n\
-    bool enableDepthTest = temp2 != 0.0;\n\
-    bool applyTranslate = floor(temp) != 0.0;\n\
-\n\
-    if (enableDepthTest) {\n\
-        temp = v_compressed.z;\n\
-        temp = temp * SHIFT_RIGHT12;\n\
-\n\
-        vec2 dimensions;\n\
-        dimensions.y = (temp - floor(temp)) * SHIFT_LEFT12;\n\
-        dimensions.x = floor(temp);\n\
-\n\
-        temp = v_compressed.w;\n\
-        temp = temp * SHIFT_RIGHT12;\n\
-\n\
-        vec2 imageSize;\n\
-        imageSize.y = (temp - floor(temp)) * SHIFT_LEFT12;\n\
-        imageSize.x = floor(temp);\n\
-\n\
-        vec2 adjustedST = v_textureCoordinates - v_textureCoordinateBounds.xy;\n\
-        adjustedST = adjustedST / vec2(v_textureCoordinateBounds.z - v_textureCoordinateBounds.x, v_textureCoordinateBounds.w - v_textureCoordinateBounds.y);\n\
-\n\
-        float epsilonEyeDepth = v_compressed.x + czm_epsilon1;\n\
-        float globeDepth1 = getGlobeDepth(adjustedST, v_originTextureCoordinateAndTranslate.xy, applyTranslate, dimensions, imageSize);\n\
-\n\
-        // negative values go into the screen\n\
-        if (globeDepth1 != 0.0 && globeDepth1 > epsilonEyeDepth)\n\
-        {\n\
-            float globeDepth2 = getGlobeDepth(adjustedST, vec2(0.0, 1.0), applyTranslate, dimensions, imageSize); // top left corner\n\
-            if (globeDepth2 != 0.0 && globeDepth2 > epsilonEyeDepth)\n\
-            {\n\
-                float globeDepth3 = getGlobeDepth(adjustedST, vec2(1.0, 1.0), applyTranslate, dimensions, imageSize); // top right corner\n\
-                if (globeDepth3 != 0.0 && globeDepth3 > epsilonEyeDepth)\n\
-                {\n\
-                    discard;\n\
-                }\n\
-            }\n\
-        }\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\
-#endif\n\
 \n\
-}\n\
-";
+    czm_writeLogDepth(depthArg);\n\
+#endif\n\
+}";

package/Source/Shaders/BillboardCollectionVS.glsl

@@ -1,3 +1,4 @@
+uniform float u_threePointDepthTestDistance;
 #ifdef INSTANCED
 in vec2 direction;
 #endif
@@ -9,10 +10,10 @@ in vec4 compressedAttribute2;                       // label horizontal origin,
 in vec4 eyeOffset;                                  // eye offset in meters, 4 bytes free (texture range)
 in vec4 scaleByDistance;                            // near, nearScale, far, farScale
 in vec4 pixelOffsetScaleByDistance;                 // near, nearScale, far, farScale
-in vec4 compressedAttribute3;                       // distance display condition near, far, disableDepthTestDistance, dimensions
+in vec4 compressedAttribute3;                       // distance display condition near, far, disableDepthTestDistanceSq, dimensions
 in vec2 sdf;                                        // sdf outline color (rgb) and width (w)
 in float splitDirection;                            // splitDirection
-#if defined(VERTEX_DEPTH_CHECK) || defined(FRAGMENT_DEPTH_CHECK)
+#if defined(VS_THREE_POINT_DEPTH_CHECK) || defined(FS_THREE_POINT_DEPTH_CHECK)
 in vec4 textureCoordinateBoundsOrLabelTranslate;    // the min and max x and y values for the texture coordinates
 #endif
 #ifdef VECTOR_TILE
@@ -20,12 +21,12 @@ in float a_batchId;
 #endif
 
 out vec2 v_textureCoordinates;
-#ifdef FRAGMENT_DEPTH_CHECK
+#ifdef FS_THREE_POINT_DEPTH_CHECK
 out vec4 v_textureCoordinateBounds;
 out vec4 v_originTextureCoordinateAndTranslate;
-out vec4 v_compressed;                                 // x: eyeDepth, y: applyTranslate & enableDepthCheck, z: dimensions, w: imageSize
 out mat2 v_rotationMatrix;
 #endif
+out vec4 v_compressed;                                 // x: eyeDepth, y: applyTranslate & enableDepthCheck, z: dimensions, w: imageSize
 
 out vec4 v_pickColor;
 out vec4 v_color;
@@ -92,7 +93,7 @@ vec4 addScreenSpaceOffset(vec4 positionEC, vec2 imageSize, float scale, vec2 dir
     return positionEC;
 }
 
-#ifdef VERTEX_DEPTH_CHECK
+#ifdef VS_THREE_POINT_DEPTH_CHECK
 float getGlobeDepth(vec4 positionEC)
 {
     vec4 posWC = czm_eyeToWindowCoordinates(positionEC);
@@ -137,7 +138,7 @@ void main()
     origin.y = floor(compressed * SHIFT_RIGHT3);
     compressed -= origin.y * SHIFT_LEFT3;
 
-#ifdef FRAGMENT_DEPTH_CHECK
+#ifdef FS_THREE_POINT_DEPTH_CHECK
     vec2 depthOrigin = origin.xy;
 #endif
     origin -= vec2(1.0);
@@ -176,10 +177,10 @@ void main()
 
     vec2 imageSize = vec2(floor(temp), temp2);
 
-#ifdef FRAGMENT_DEPTH_CHECK
+#ifdef FS_THREE_POINT_DEPTH_CHECK
     float labelHorizontalOrigin = floor(compressedAttribute2.w - (temp2 * SHIFT_LEFT2));
     float applyTranslate = 0.0;
-    if (labelHorizontalOrigin != 0.0) // is a billboard, so set apply translate to false
+    if (labelHorizontalOrigin != 0.0) // is a label, so set apply translate to true
     {
         applyTranslate = 1.0;
         labelHorizontalOrigin -= 2.0;
@@ -200,7 +201,7 @@ void main()
     translucencyByDistance.w = ((temp - floor(temp)) * SHIFT_LEFT8) / 255.0;
 #endif
 
-#if defined(VERTEX_DEPTH_CHECK) || defined(FRAGMENT_DEPTH_CHECK)
+#if defined(VS_THREE_POINT_DEPTH_CHECK) || defined(FS_THREE_POINT_DEPTH_CHECK)
     temp = compressedAttribute3.w;
     temp = temp * SHIFT_RIGHT12;
 
@@ -250,10 +251,6 @@ void main()
     vec4 p = czm_translateRelativeToEye(positionHigh, positionLow);
     vec4 positionEC = czm_modelViewRelativeToEye * p;
 
-#if defined(FRAGMENT_DEPTH_CHECK) || defined(VERTEX_DEPTH_CHECK)
-    float eyeDepth = positionEC.z;
-#endif
-
     positionEC = czm_eyeOffset(positionEC, eyeOffset.xyz);
     positionEC.xyz *= show;
 
@@ -311,35 +308,56 @@ void main()
     mat2 rotationMatrix;
     float mpp;
 
+    float enableDepthCheck = 1.0;
 #ifdef DISABLE_DEPTH_DISTANCE
-    float disableDepthTestDistance = compressedAttribute3.z;
+    float disableDepthTestDistanceSq = compressedAttribute3.z;
+    if (disableDepthTestDistanceSq == 0.0 && czm_minimumDisableDepthTestDistance != 0.0)
+    {
+        disableDepthTestDistanceSq = czm_minimumDisableDepthTestDistance;
+    }
+
+    if (lengthSq < disableDepthTestDistanceSq || disableDepthTestDistanceSq < 0.0)
+    {
+        enableDepthCheck = 0.0;
+    }
 #endif
 
-#ifdef VERTEX_DEPTH_CHECK
-if (lengthSq < disableDepthTestDistance) {
-    float depthsilon = 10.0;
+    v_compressed.y = enableDepthCheck;
 
-    vec2 labelTranslate = textureCoordinateBoundsOrLabelTranslate.xy;
-    vec4 pEC1 = addScreenSpaceOffset(positionEC, dimensions, scale, vec2(0.0), origin, labelTranslate, pixelOffset, alignedAxis, validAlignedAxis, rotation, sizeInMeters, rotationMatrix, mpp);
+#ifdef VS_THREE_POINT_DEPTH_CHECK
+if (lengthSq < (u_threePointDepthTestDistance * u_threePointDepthTestDistance) && (enableDepthCheck == 1.0)) {
+    float depthsilon = 10.0;
+    vec2 depthOrigin;
+    // Horizontal origin for labels comes from a special attribute. If that value is 0, this is a billboard - use the regular origin. 
+    // Otherwise, transform the label origin to -1, 0, 1 (right, center, left).
+    depthOrigin.x = floor(compressedAttribute2.w - (temp2 * SHIFT_LEFT2));
+    depthOrigin.x = czm_branchFreeTernary(depthOrigin.x == 0.0, origin.x, depthOrigin.x - 2.0);
+    depthOrigin.y = origin.y;
+
+    vec4 pEC1 = addScreenSpaceOffset(positionEC, dimensions, scale, vec2(0.0), depthOrigin, vec2(0.0), pixelOffset, alignedAxis, validAlignedAxis, rotation, sizeInMeters, rotationMatrix, mpp);
     float globeDepth1 = getGlobeDepth(pEC1);
 
     if (globeDepth1 != 0.0 && pEC1.z + depthsilon < globeDepth1)
     {
-        vec4 pEC2 = addScreenSpaceOffset(positionEC, dimensions, scale, vec2(0.0, 1.0), origin, labelTranslate, pixelOffset, alignedAxis, validAlignedAxis, rotation, sizeInMeters, rotationMatrix, mpp);
+        vec4 pEC2 = addScreenSpaceOffset(positionEC, dimensions, scale, vec2(0.0, 1.0), depthOrigin, vec2(0.0), pixelOffset, alignedAxis, validAlignedAxis, rotation, sizeInMeters, rotationMatrix, mpp);
         float globeDepth2 = getGlobeDepth(pEC2);
 
         if (globeDepth2 != 0.0 && pEC2.z + depthsilon < globeDepth2)
         {
-            vec4 pEC3 = addScreenSpaceOffset(positionEC, dimensions, scale, vec2(1.0), origin, labelTranslate, pixelOffset, alignedAxis, validAlignedAxis, rotation, sizeInMeters, rotationMatrix, mpp);
+            vec4 pEC3 = addScreenSpaceOffset(positionEC, dimensions, scale, vec2(1.0), depthOrigin, vec2(0.0), pixelOffset, alignedAxis, validAlignedAxis, rotation, sizeInMeters, rotationMatrix, mpp);
             float globeDepth3 = getGlobeDepth(pEC3);
             if (globeDepth3 != 0.0 && pEC3.z + depthsilon < globeDepth3)
             {
+                // "Discard" this vertex, as three key points fail depth test.
                 positionEC.xyz = vec3(0.0);
             }
         }
     }
 }
 #endif
+    // Write out the eyespace depth before applying the screen space offset, but after potentially "discarding" the vertex
+    // by setting its eyespace position to zero, via the three-point depth test above.
+    v_compressed.x = positionEC.z;
 
     positionEC = addScreenSpaceOffset(positionEC, imageSize, scale, direction, origin, translate, pixelOffset, alignedAxis, validAlignedAxis, rotation, sizeInMeters, rotationMatrix, mpp);
     gl_Position = czm_projection * positionEC;
@@ -350,17 +368,14 @@ if (lengthSq < disableDepthTestDistance) {
 #endif
 
 #ifdef DISABLE_DEPTH_DISTANCE
-    if (disableDepthTestDistance == 0.0 && czm_minimumDisableDepthTestDistance != 0.0)
-    {
-        disableDepthTestDistance = czm_minimumDisableDepthTestDistance;
-    }
 
-    if (disableDepthTestDistance != 0.0)
+    if (disableDepthTestDistanceSq != 0.0)
     {
         // Don't try to "multiply both sides" by w.  Greater/less-than comparisons won't work for negative values of w.
         float zclip = gl_Position.z / gl_Position.w;
         bool clipped = (zclip < -1.0 || zclip > 1.0);
-        if (!clipped && (disableDepthTestDistance < 0.0 || (lengthSq > 0.0 && lengthSq < disableDepthTestDistance)))
+        // disableDepthTestDistanceSq can be less than zero if it's explicitly set to -1 in JS (as a sentinel value equivalent to infinity)
+        if (!clipped && (disableDepthTestDistanceSq < 0.0 || (lengthSq > 0.0 && lengthSq < disableDepthTestDistanceSq)))
         {
             // Position z on the near plane.
             gl_Position.z = -gl_Position.w;
@@ -371,7 +386,7 @@ if (lengthSq < disableDepthTestDistance) {
     }
 #endif
 
-#ifdef FRAGMENT_DEPTH_CHECK
+#ifdef FS_THREE_POINT_DEPTH_CHECK
     if (sizeInMeters) {
         translate /= mpp;
         dimensions /= mpp;
@@ -383,21 +398,13 @@ if (lengthSq < disableDepthTestDistance) {
 #else
     v_rotationMatrix = mat2(1.0, 0.0, 0.0, 1.0);
 #endif
-
-    float enableDepthCheck = 0.0;
-    if (lengthSq < disableDepthTestDistance)
-    {
-        enableDepthCheck = 1.0;
-    }
-
     float dw = floor(clamp(dimensions.x, 0.0, SHIFT_LEFT12));
     float dh = floor(clamp(dimensions.y, 0.0, SHIFT_LEFT12));
 
     float iw = floor(clamp(imageSize.x, 0.0, SHIFT_LEFT12));
     float ih = floor(clamp(imageSize.y, 0.0, SHIFT_LEFT12));
 
-    v_compressed.x = eyeDepth;
-    v_compressed.y = applyTranslate * SHIFT_LEFT1 + enableDepthCheck;
+    v_compressed.y += applyTranslate * SHIFT_LEFT1;
     v_compressed.z = dw * SHIFT_LEFT12 + dh;
     v_compressed.w = iw * SHIFT_LEFT12 + ih;
     v_originTextureCoordinateAndTranslate.xy = depthOrigin;