@cesium/engine 22.2.0 → 23.0.0

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\
+";

package/Source/Shaders/BillboardCollectionVS.glsl

@@ -26,11 +26,11 @@ out vec4 v_textureCoordinateBounds;
 out vec4 v_originTextureCoordinateAndTranslate;
 out mat2 v_rotationMatrix;
 #endif
-out vec4 v_compressed;                                 // x: eyeDepth, y: applyTranslate & enableDepthCheck, z: dimensions, w: imageSize
+out vec4 v_compressed;             // x: eyeDepth, y: applyTranslate & enableDepthCheck, z: dimensions, w: imageSize
 
 out vec4 v_pickColor;
 out vec4 v_color;
-out float v_splitDirection;
+flat out vec2 v_splitDirectionAndEllipsoidDepthEC;  // x: splitDirection, y: ellipsoid depth in eye coordinates
 #ifdef SDF
 out vec4 v_outlineColor;
 out float v_outlineWidth;
@@ -219,32 +219,18 @@ void main()
     bool validAlignedAxis = false;
 #endif
 
-    vec4 pickColor;
-    vec4 color;
-
-    temp = compressedAttribute2.y;
-    temp = temp * SHIFT_RIGHT8;
-    pickColor.b = (temp - floor(temp)) * SHIFT_LEFT8;
-    temp = floor(temp) * SHIFT_RIGHT8;
-    pickColor.g = (temp - floor(temp)) * SHIFT_LEFT8;
-    pickColor.r = floor(temp);
-
-    temp = compressedAttribute2.x;
-    temp = temp * SHIFT_RIGHT8;
-    color.b = (temp - floor(temp)) * SHIFT_LEFT8;
-    temp = floor(temp) * SHIFT_RIGHT8;
-    color.g = (temp - floor(temp)) * SHIFT_LEFT8;
-    color.r = floor(temp);
+    vec4 color = czm_decodeRGB8(compressedAttribute2.x);
+    vec4 pickColor = czm_decodeRGB8(compressedAttribute2.y);
 
     temp = compressedAttribute2.z * SHIFT_RIGHT8;
     bool sizeInMeters = floor((temp - floor(temp)) * SHIFT_LEFT7) > 0.0;
     temp = floor(temp) * SHIFT_RIGHT8;
 
     pickColor.a = (temp - floor(temp)) * SHIFT_LEFT8;
-    pickColor /= 255.0;
+    pickColor.a /= 255.0;
 
     color.a = floor(temp);
-    color /= 255.0;
+    color.a /= 255.0;
 
     ///////////////////////////////////////////////////////////////////////////
 
@@ -322,13 +308,25 @@ void main()
     }
 #endif
 
+    v_splitDirectionAndEllipsoidDepthEC.y = czm_infinity;
+    vec3 ellipsoidCenter = czm_view[3].xyz;
+    vec3 rayDirection = normalize(positionEC.xyz);
+    czm_ray ray = czm_ray(vec3(0.0), rayDirection);
+    vec3 ellipsoid_inverseRadii = czm_ellipsoidInverseRadii;
+    czm_raySegment intersection = czm_rayEllipsoidIntersectionInterval(ray, ellipsoidCenter, ellipsoid_inverseRadii);
+
+    if (!czm_isEmpty(intersection))
+    {
+        v_splitDirectionAndEllipsoidDepthEC.y = intersection.start;
+    }
+
     v_compressed.y = enableDepthCheck;
 
 #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. 
+    // 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);
@@ -414,23 +412,16 @@ if (lengthSq < (u_threePointDepthTestDistance * u_threePointDepthTestDistance) &
 #endif
 
 #ifdef SDF
-    vec4 outlineColor;
+    vec4 outlineColor = czm_decodeRGB8(sdf.x);
     float outlineWidth;
 
-    temp = sdf.x;
-    temp = temp * SHIFT_RIGHT8;
-    outlineColor.b = (temp - floor(temp)) * SHIFT_LEFT8;
-    temp = floor(temp) * SHIFT_RIGHT8;
-    outlineColor.g = (temp - floor(temp)) * SHIFT_LEFT8;
-    outlineColor.r = floor(temp);
-
     temp = sdf.y;
     temp = temp * SHIFT_RIGHT8;
     float temp3 = (temp - floor(temp)) * SHIFT_LEFT8;
     temp = floor(temp) * SHIFT_RIGHT8;
     outlineWidth = (temp - floor(temp)) * SHIFT_LEFT8;
     outlineColor.a = floor(temp);
-    outlineColor /= 255.0;
+    outlineColor.a /= 255.0;
 
     v_outlineWidth = outlineWidth / 255.0;
     v_outlineColor = outlineColor;
@@ -441,5 +432,5 @@ if (lengthSq < (u_threePointDepthTestDistance * u_threePointDepthTestDistance) &
 
     v_color = color;
     v_color.a *= translucency;
-    v_splitDirection = splitDirection;
+    v_splitDirectionAndEllipsoidDepthEC.x = splitDirection;
 }

package/Source/Shaders/BillboardCollectionVS.js

@@ -27,11 +27,11 @@ out vec4 v_textureCoordinateBounds;\n\
 out vec4 v_originTextureCoordinateAndTranslate;\n\
 out mat2 v_rotationMatrix;\n\
 #endif\n\
-out vec4 v_compressed;                                 // x: eyeDepth, y: applyTranslate & enableDepthCheck, z: dimensions, w: imageSize\n\
+out vec4 v_compressed;             // x: eyeDepth, y: applyTranslate & enableDepthCheck, z: dimensions, w: imageSize\n\
 \n\
 out vec4 v_pickColor;\n\
 out vec4 v_color;\n\
-out float v_splitDirection;\n\
+flat out vec2 v_splitDirectionAndEllipsoidDepthEC;  // x: splitDirection, y: ellipsoid depth in eye coordinates\n\
 #ifdef SDF\n\
 out vec4 v_outlineColor;\n\
 out float v_outlineWidth;\n\
@@ -220,32 +220,18 @@ void main()\n\
     bool validAlignedAxis = false;\n\
 #endif\n\
 \n\
-    vec4 pickColor;\n\
-    vec4 color;\n\
-\n\
-    temp = compressedAttribute2.y;\n\
-    temp = temp * SHIFT_RIGHT8;\n\
-    pickColor.b = (temp - floor(temp)) * SHIFT_LEFT8;\n\
-    temp = floor(temp) * SHIFT_RIGHT8;\n\
-    pickColor.g = (temp - floor(temp)) * SHIFT_LEFT8;\n\
-    pickColor.r = floor(temp);\n\
-\n\
-    temp = compressedAttribute2.x;\n\
-    temp = temp * SHIFT_RIGHT8;\n\
-    color.b = (temp - floor(temp)) * SHIFT_LEFT8;\n\
-    temp = floor(temp) * SHIFT_RIGHT8;\n\
-    color.g = (temp - floor(temp)) * SHIFT_LEFT8;\n\
-    color.r = floor(temp);\n\
+    vec4 color = czm_decodeRGB8(compressedAttribute2.x);\n\
+    vec4 pickColor = czm_decodeRGB8(compressedAttribute2.y);\n\
 \n\
     temp = compressedAttribute2.z * SHIFT_RIGHT8;\n\
     bool sizeInMeters = floor((temp - floor(temp)) * SHIFT_LEFT7) > 0.0;\n\
     temp = floor(temp) * SHIFT_RIGHT8;\n\
 \n\
     pickColor.a = (temp - floor(temp)) * SHIFT_LEFT8;\n\
-    pickColor /= 255.0;\n\
+    pickColor.a /= 255.0;\n\
 \n\
     color.a = floor(temp);\n\
-    color /= 255.0;\n\
+    color.a /= 255.0;\n\
 \n\
     ///////////////////////////////////////////////////////////////////////////\n\
 \n\
@@ -322,6 +308,18 @@ void main()\n\
         enableDepthCheck = 0.0;\n\
     }\n\
 #endif\n\
+\n\
+    v_splitDirectionAndEllipsoidDepthEC.y = czm_infinity;\n\
+    vec3 ellipsoidCenter = czm_view[3].xyz;\n\
+    vec3 rayDirection = normalize(positionEC.xyz);\n\
+    czm_ray ray = czm_ray(vec3(0.0), rayDirection);\n\
+    vec3 ellipsoid_inverseRadii = czm_ellipsoidInverseRadii;\n\
+    czm_raySegment intersection = czm_rayEllipsoidIntersectionInterval(ray, ellipsoidCenter, ellipsoid_inverseRadii);\n\
+\n\
+    if (!czm_isEmpty(intersection))\n\
+    {\n\
+        v_splitDirectionAndEllipsoidDepthEC.y = intersection.start;\n\
+    }\n\
 \n\
     v_compressed.y = enableDepthCheck;\n\
 \n\
@@ -329,7 +327,7 @@ void main()\n\
 if (lengthSq < (u_threePointDepthTestDistance * u_threePointDepthTestDistance) && (enableDepthCheck == 1.0)) {\n\
     float depthsilon = 10.0;\n\
     vec2 depthOrigin;\n\
-    // Horizontal origin for labels comes from a special attribute. If that value is 0, this is a billboard - use the regular origin. \n\
+    // Horizontal origin for labels comes from a special attribute. If that value is 0, this is a billboard - use the regular origin.\n\
     // Otherwise, transform the label origin to -1, 0, 1 (right, center, left).\n\
     depthOrigin.x = floor(compressedAttribute2.w - (temp2 * SHIFT_LEFT2));\n\
     depthOrigin.x = czm_branchFreeTernary(depthOrigin.x == 0.0, origin.x, depthOrigin.x - 2.0);\n\
@@ -415,15 +413,8 @@ if (lengthSq < (u_threePointDepthTestDistance * u_threePointDepthTestDistance) &
 #endif\n\
 \n\
 #ifdef SDF\n\
-    vec4 outlineColor;\n\
+    vec4 outlineColor = czm_decodeRGB8(sdf.x);\n\
     float outlineWidth;\n\
-\n\
-    temp = sdf.x;\n\
-    temp = temp * SHIFT_RIGHT8;\n\
-    outlineColor.b = (temp - floor(temp)) * SHIFT_LEFT8;\n\
-    temp = floor(temp) * SHIFT_RIGHT8;\n\
-    outlineColor.g = (temp - floor(temp)) * SHIFT_LEFT8;\n\
-    outlineColor.r = floor(temp);\n\
 \n\
     temp = sdf.y;\n\
     temp = temp * SHIFT_RIGHT8;\n\
@@ -431,7 +422,7 @@ if (lengthSq < (u_threePointDepthTestDistance * u_threePointDepthTestDistance) &
     temp = floor(temp) * SHIFT_RIGHT8;\n\
     outlineWidth = (temp - floor(temp)) * SHIFT_LEFT8;\n\
     outlineColor.a = floor(temp);\n\
-    outlineColor /= 255.0;\n\
+    outlineColor.a /= 255.0;\n\
 \n\
     v_outlineWidth = outlineWidth / 255.0;\n\
     v_outlineColor = outlineColor;\n\
@@ -442,6 +433,6 @@ if (lengthSq < (u_threePointDepthTestDistance * u_threePointDepthTestDistance) &
 \n\
     v_color = color;\n\
     v_color.a *= translucency;\n\
-    v_splitDirection = splitDirection;\n\
+    v_splitDirectionAndEllipsoidDepthEC.x = splitDirection;\n\
 }\n\
 ";

package/Source/Shaders/Builtin/CzmBuiltins.js

@@ -72,6 +72,7 @@ import czm_computeGroundAtmosphereScattering from './Functions/computeGroundAtmo
 import czm_computePosition from './Functions/computePosition.js'
 import czm_computeScattering from './Functions/computeScattering.js'
 import czm_cosineAndSine from './Functions/cosineAndSine.js'
+import czm_decodeRGB8 from './Functions/decodeRGB8.js'
 import czm_decompressTextureCoordinates from './Functions/decompressTextureCoordinates.js'
 import czm_depthClamp from './Functions/depthClamp.js'
 import czm_eastNorthUpToEyeCoordinates from './Functions/eastNorthUpToEyeCoordinates.js'
@@ -130,6 +131,7 @@ import czm_transpose from './Functions/transpose.js'
 import czm_unpackClippingExtents from './Functions/unpackClippingExtents.js'
 import czm_unpackDepth from './Functions/unpackDepth.js'
 import czm_unpackFloat from './Functions/unpackFloat.js'
+import czm_unpackTexture from './Functions/unpackTexture.js'
 import czm_unpackUint from './Functions/unpackUint.js'
 import czm_valueTransform from './Functions/valueTransform.js'
 import czm_vertexLogDepth from './Functions/vertexLogDepth.js'
@@ -212,6 +214,7 @@ export default {
     czm_computePosition : czm_computePosition,
     czm_computeScattering : czm_computeScattering,
     czm_cosineAndSine : czm_cosineAndSine,
+    czm_decodeRGB8 : czm_decodeRGB8,
     czm_decompressTextureCoordinates : czm_decompressTextureCoordinates,
     czm_depthClamp : czm_depthClamp,
     czm_eastNorthUpToEyeCoordinates : czm_eastNorthUpToEyeCoordinates,
@@ -270,6 +273,7 @@ export default {
     czm_unpackClippingExtents : czm_unpackClippingExtents,
     czm_unpackDepth : czm_unpackDepth,
     czm_unpackFloat : czm_unpackFloat,
+    czm_unpackTexture : czm_unpackTexture,
     czm_unpackUint : czm_unpackUint,
     czm_valueTransform : czm_valueTransform,
     czm_vertexLogDepth : czm_vertexLogDepth,

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

@@ -7,6 +7,13 @@
 vec4 czm_columbusViewMorph(vec4 position2D, vec4 position3D, float time)
 {
     // Just linear for now.
-    vec3 p = mix(position2D.xyz, position3D.xyz, time);
+    // We're manually doing the equivalent of a `mix` here because, some GPUs
+    // (NVidia GeForce 3070 Ti and Intel Arc A750, to name two), `mix` seems to
+    // use an alternate formulation that introduces jitter even when `time` is
+    // 0.0 or 1.0. That is, the value of `p` won't be exactly `position2D.xyz`
+    // when `time` is 0.0 and it won't be exactly `position3D.xyz` when `time` is
+    // 1.0. The "textbook" formulation here, while probably a bit slower,
+    // does not have this problem.
+    vec3 p = position2D.xyz * (1.0 - time) + position3D.xyz * time;
     return vec4(p, 1.0);
 }

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

@@ -8,7 +8,14 @@ export default "/**\n\
 vec4 czm_columbusViewMorph(vec4 position2D, vec4 position3D, float time)\n\
 {\n\
     // Just linear for now.\n\
-    vec3 p = mix(position2D.xyz, position3D.xyz, time);\n\
+    // We're manually doing the equivalent of a `mix` here because, some GPUs\n\
+    // (NVidia GeForce 3070 Ti and Intel Arc A750, to name two), `mix` seems to\n\
+    // use an alternate formulation that introduces jitter even when `time` is\n\
+    // 0.0 or 1.0. That is, the value of `p` won't be exactly `position2D.xyz`\n\
+    // when `time` is 0.0 and it won't be exactly `position3D.xyz` when `time` is\n\
+    // 1.0. The \"textbook\" formulation here, while probably a bit slower,\n\
+    // does not have this problem.\n\
+    vec3 p = position2D.xyz * (1.0 - time) + position3D.xyz * time;\n\
     return vec4(p, 1.0);\n\
 }\n\
 ";

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

@@ -0,0 +1,22 @@
+/**
+ * Decodes RGB values packed into a single float at 8-bit precision. Encoded
+ * representation is equivalent to 0xFFFFFF in JavaScript.
+ *
+ * @name czm_decodeRGB8
+ * @glslFunction
+ *
+ * @param {float} encoded Float-encoded RGB values.
+ * @returns {vec4} Decoded RGB values.
+ */
+vec4 czm_decodeRGB8(float encoded) {
+    const float SHIFT_RIGHT16 = 1.0 / 65536.0;
+    const float SHIFT_RIGHT8 = 1.0 / 256.0;
+    const float SHIFT_LEFT16 = 65536.0;
+    const float SHIFT_LEFT8 = 256.0;
+
+    vec4 color = vec4(255.0);
+    color.r = floor(encoded * SHIFT_RIGHT16);
+    color.g = floor((encoded - color.r * SHIFT_LEFT16) * SHIFT_RIGHT8);
+    color.b = floor(encoded - color.r * SHIFT_LEFT16 - color.g * SHIFT_LEFT8);
+    return color / 255.0;
+}

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

@@ -0,0 +1,24 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "/**\n\
+ * Decodes RGB values packed into a single float at 8-bit precision. Encoded\n\
+ * representation is equivalent to 0xFFFFFF in JavaScript.\n\
+ *\n\
+ * @name czm_decodeRGB8\n\
+ * @glslFunction\n\
+ *\n\
+ * @param {float} encoded Float-encoded RGB values.\n\
+ * @returns {vec4} Decoded RGB values.\n\
+ */\n\
+vec4 czm_decodeRGB8(float encoded) {\n\
+    const float SHIFT_RIGHT16 = 1.0 / 65536.0;\n\
+    const float SHIFT_RIGHT8 = 1.0 / 256.0;\n\
+    const float SHIFT_LEFT16 = 65536.0;\n\
+    const float SHIFT_LEFT8 = 256.0;\n\
+\n\
+    vec4 color = vec4(255.0);\n\
+    color.r = floor(encoded * SHIFT_RIGHT16);\n\
+    color.g = floor((encoded - color.r * SHIFT_LEFT16) * SHIFT_RIGHT8);\n\
+    color.b = floor(encoded - color.r * SHIFT_LEFT16 - color.g * SHIFT_LEFT8);\n\
+    return color / 255.0;\n\
+}\n\
+";