@hztxi/cesium-engine 25.0.6 → 26.2.1

package/Source/Shaders/Builtin/CzmBuiltins.js

@@ -15,6 +15,8 @@ import czm_passCesium3DTile from './Constants/passCesium3DTile.js'
 import czm_passCesium3DTileClassification from './Constants/passCesium3DTileClassification.js'
 import czm_passCesium3DTileClassificationIgnoreShow from './Constants/passCesium3DTileClassificationIgnoreShow.js'
 import czm_passCesium3DTileEdges from './Constants/passCesium3DTileEdges.js'
+import czm_passCesium3DTileEdgesDirect from './Constants/passCesium3DTileEdgesDirect.js'
+import czm_passCesium3DTilePlanarFillId from './Constants/passCesium3DTilePlanarFillId.js'
 import czm_passClassification from './Constants/passClassification.js'
 import czm_passCompute from './Constants/passCompute.js'
 import czm_passEnvironment from './Constants/passEnvironment.js'
@@ -158,6 +160,8 @@ export default {
     czm_passCesium3DTileClassification : czm_passCesium3DTileClassification,
     czm_passCesium3DTileClassificationIgnoreShow : czm_passCesium3DTileClassificationIgnoreShow,
     czm_passCesium3DTileEdges : czm_passCesium3DTileEdges,
+    czm_passCesium3DTileEdgesDirect : czm_passCesium3DTileEdgesDirect,
+    czm_passCesium3DTilePlanarFillId : czm_passCesium3DTilePlanarFillId,
     czm_passClassification : czm_passClassification,
     czm_passCompute : czm_passCompute,
     czm_passEnvironment : czm_passEnvironment,

package/Source/Shaders/GlobeFS.glsl

@@ -121,7 +121,7 @@ uniform float u_minimumBrightness;
 #endif
 
 // Based on colorCorrect
-// The colorCorrect flag can only be true when tileProvider.hue/saturation/brightnessShift 
+// The colorCorrect flag can only be true when tileProvider.hue/saturation/brightnessShift
 // are nonzero AND when (applyFog || showGroundAtmosphere) in the tile provider
 // - The tileProvider.hue/saturation/brightnessShift are just passed through
 //   from the Globe hue/saturation/brightness, like atmosphereBrightnessShift
@@ -149,8 +149,8 @@ uniform vec4 u_translucencyRectangle;
 #endif
 
 // Based on showUndergroundColor
-// This is set when GlobeSurfaceTileProvider.isUndergroundVisible 
-// returns true, AND the tileProvider.undergroundColor had a value with 
+// This is set when GlobeSurfaceTileProvider.isUndergroundVisible
+// returns true, AND the tileProvider.undergroundColor had a value with
 // nonzero alpha, and the tileProvider.undergroundColorAlphaByDistance
 // was in the right range
 #ifdef UNDERGROUND_COLOR
@@ -618,11 +618,16 @@ void main()
     }
 #endif
 
+#ifdef HAS_VECTOR_LAYER
+    finalColor = vectorPolygonRender(v_textureCoordinates.xy, finalColor);
+    finalColor = vectorPolylineRender(v_textureCoordinates.xy, finalColor);
+#endif
+
 #ifdef TRANSLUCENT
     if (inTranslucencyRectangle())
     {
-      vec4 alphaByDistance = gl_FrontFacing ? u_frontFaceAlphaByDistance : u_backFaceAlphaByDistance;
-      finalColor.a *= interpolateByDistance(alphaByDistance, v_distance);
+        vec4 alphaByDistance = gl_FrontFacing ? u_frontFaceAlphaByDistance : u_backFaceAlphaByDistance;
+        finalColor.a *= interpolateByDistance(alphaByDistance, v_distance);
     }
 #endif
 
@@ -732,4 +737,3 @@ vec4 computeWaterColor(vec3 positionEyeCoordinates, vec2 textureCoordinates, mat
 }
 
 #endif // #ifdef SHOW_REFLECTIVE_OCEAN
-

package/Source/Shaders/GlobeFS.js

@@ -122,7 +122,7 @@ uniform float u_minimumBrightness;\n\
 #endif\n\
 \n\
 // Based on colorCorrect\n\
-// The colorCorrect flag can only be true when tileProvider.hue/saturation/brightnessShift \n\
+// The colorCorrect flag can only be true when tileProvider.hue/saturation/brightnessShift\n\
 // are nonzero AND when (applyFog || showGroundAtmosphere) in the tile provider\n\
 // - The tileProvider.hue/saturation/brightnessShift are just passed through\n\
 //   from the Globe hue/saturation/brightness, like atmosphereBrightnessShift\n\
@@ -150,8 +150,8 @@ uniform vec4 u_translucencyRectangle;\n\
 #endif\n\
 \n\
 // Based on showUndergroundColor\n\
-// This is set when GlobeSurfaceTileProvider.isUndergroundVisible \n\
-// returns true, AND the tileProvider.undergroundColor had a value with \n\
+// This is set when GlobeSurfaceTileProvider.isUndergroundVisible\n\
+// returns true, AND the tileProvider.undergroundColor had a value with\n\
 // nonzero alpha, and the tileProvider.undergroundColorAlphaByDistance\n\
 // was in the right range\n\
 #ifdef UNDERGROUND_COLOR\n\
@@ -619,11 +619,16 @@ void main()\n\
     }\n\
 #endif\n\
 \n\
+#ifdef HAS_VECTOR_LAYER\n\
+    finalColor = vectorPolygonRender(v_textureCoordinates.xy, finalColor);\n\
+    finalColor = vectorPolylineRender(v_textureCoordinates.xy, finalColor);\n\
+#endif\n\
+\n\
 #ifdef TRANSLUCENT\n\
     if (inTranslucencyRectangle())\n\
     {\n\
-      vec4 alphaByDistance = gl_FrontFacing ? u_frontFaceAlphaByDistance : u_backFaceAlphaByDistance;\n\
-      finalColor.a *= interpolateByDistance(alphaByDistance, v_distance);\n\
+        vec4 alphaByDistance = gl_FrontFacing ? u_frontFaceAlphaByDistance : u_backFaceAlphaByDistance;\n\
+        finalColor.a *= interpolateByDistance(alphaByDistance, v_distance);\n\
     }\n\
 #endif\n\
 \n\
@@ -733,5 +738,4 @@ vec4 computeWaterColor(vec3 positionEyeCoordinates, vec2 textureCoordinates, mat
 }\n\
 \n\
 #endif // #ifdef SHOW_REFLECTIVE_OCEAN\n\
-\n\
 ";

package/Source/Shaders/Materials/PolylineGlowMaterial.glsl

@@ -15,7 +15,7 @@ czm_material czm_getMaterial(czm_materialInput materialInput)
 
     vec4 fragColor;
     fragColor.rgb = max(vec3(glow - 1.0 + color.rgb), color.rgb);
-    fragColor.a = clamp(0.0, 1.0, glow) * color.a;
+    fragColor.a = clamp(glow, 0.0, 1.0) * color.a;
     fragColor = czm_gammaCorrect(fragColor);
 
     material.emission = fragColor.rgb;

package/Source/Shaders/Materials/PolylineGlowMaterial.js

@@ -16,7 +16,7 @@ czm_material czm_getMaterial(czm_materialInput materialInput)\n\
 \n\
     vec4 fragColor;\n\
     fragColor.rgb = max(vec3(glow - 1.0 + color.rgb), color.rgb);\n\
-    fragColor.a = clamp(0.0, 1.0, glow) * color.a;\n\
+    fragColor.a = clamp(glow, 0.0, 1.0) * color.a;\n\
     fragColor = czm_gammaCorrect(fragColor);\n\
 \n\
     material.emission = fragColor.rgb;\n\

package/Source/Shaders/Model/EdgeVisibilityStageVS.glsl

@@ -5,7 +5,6 @@ void edgeVisibilityStageVS() {
     }
 
     v_edgeType = a_edgeType;
-    v_silhouetteNormalView = czm_normal * a_silhouetteNormal;
     v_faceNormalAView = czm_normal * a_faceNormalA;
     v_faceNormalBView = czm_normal * a_faceNormalB;
     v_edgeOffset = a_edgeOffset;

package/Source/Shaders/Model/EdgeVisibilityStageVS.js

@@ -6,7 +6,6 @@ void edgeVisibilityStageVS() {\n\
     }\n\
 \n\
     v_edgeType = a_edgeType;\n\
-    v_silhouetteNormalView = czm_normal * a_silhouetteNormal;\n\
     v_faceNormalAView = czm_normal * a_faceNormalA;\n\
     v_faceNormalBView = czm_normal * a_faceNormalB;\n\
     v_edgeOffset = a_edgeOffset;\n\

package/Source/Shaders/Model/MaterialStageFS.glsl

@@ -463,8 +463,14 @@ void materialStage(inout czm_modelMaterial material, ProcessedAttributes attribu
     #endif
 
     vec4 baseColorWithAlpha = vec4(1.0);
-    // Regardless of whether we use PBR, set a base color
-    #ifdef HAS_BASE_COLOR_TEXTURE
+    // Regardless of whether we use PBR, set a base color.
+    // HAS_BACKGROUND_FILL (from BENTLEY_materials_planar_fill) overrides with
+    // the view's background color to create an invisible masking polygon.
+    // The background color is in sRGB, so convert to linear to match the
+    // material pipeline's expected color space.
+    #ifdef HAS_BACKGROUND_FILL
+        baseColorWithAlpha = czm_srgbToLinear(czm_backgroundColor);
+    #elif defined(HAS_BASE_COLOR_TEXTURE)
         baseColorWithAlpha = getBaseColorFromTexture();
     #elif defined(HAS_BASE_COLOR_FACTOR)
         baseColorWithAlpha = u_baseColorFactor;

package/Source/Shaders/Model/MaterialStageFS.js

@@ -464,8 +464,14 @@ void materialStage(inout czm_modelMaterial material, ProcessedAttributes attribu
     #endif\n\
 \n\
     vec4 baseColorWithAlpha = vec4(1.0);\n\
-    // Regardless of whether we use PBR, set a base color\n\
-    #ifdef HAS_BASE_COLOR_TEXTURE\n\
+    // Regardless of whether we use PBR, set a base color.\n\
+    // HAS_BACKGROUND_FILL (from BENTLEY_materials_planar_fill) overrides with\n\
+    // the view's background color to create an invisible masking polygon.\n\
+    // The background color is in sRGB, so convert to linear to match the\n\
+    // material pipeline's expected color space.\n\
+    #ifdef HAS_BACKGROUND_FILL\n\
+        baseColorWithAlpha = czm_srgbToLinear(czm_backgroundColor);\n\
+    #elif defined(HAS_BASE_COLOR_TEXTURE)\n\
         baseColorWithAlpha = getBaseColorFromTexture();\n\
     #elif defined(HAS_BASE_COLOR_FACTOR)\n\
         baseColorWithAlpha = u_baseColorFactor;\n\

package/Source/Shaders/Model/ModelFS.glsl

@@ -1,6 +1,29 @@
 
 precision highp float;
 
+// ──────────────────────────────────────────────────────────────────────
+// BENTLEY_materials_planar_fill constants
+//
+// These factors scale gl_FragDepth AFTER czm_writeLogDepth has run, so
+// they are proportional offsets in log-depth space. The corresponding
+// eye-space offset therefore varies with the fragment's distance from
+// the camera (growing with distance). This is the intended behavior: it
+// matches the proportional depth comparison tolerance used by the edge
+// visibility system, so fills and edges stay consistently ordered at all
+// viewing distances.
+// ──────────────────────────────────────────────────────────────────────
+// Depth pull factor for all planar fills: scales log depth by 0.9995,
+// i.e. a 0.05% pull toward the camera in log-depth space.
+const float PLANAR_DEPTH_PULL = 0.9995;
+// Depth push factor for behind fills: scales log depth by 1.0002, i.e. a
+// 0.02% push away from the camera in log-depth space, so behind fills sit
+// behind same-object siblings.
+const float BEHIND_DEPTH_PUSH = 1.0002;
+// Tolerance for comparing feature IDs stored as floats (integer equality).
+const float FEATURE_ID_TOLERANCE = 0.5;
+// Offset added to feature IDs so 0 means "no planar fill" in the texture.
+const float FEATURE_ID_OFFSET = 1.0;
+
 czm_modelMaterial defaultModelMaterial()
 {
     czm_modelMaterial material;
@@ -40,6 +63,10 @@ void lineStyleStage()
 
 SelectedFeature selectedFeature;
 
+// Set by edge-pass fragments below; consumed by the snapId expression built
+// in PickingPipelineStage (see Scene#snap).
+bool isEdge = false;
+
 void main()
 {
     #if defined(PRIMITIVE_TYPE_POINTS) && defined(HAS_POINT_DIAMETER)
@@ -69,6 +96,26 @@ void main()
     FeatureIds featureIds;
     featureIdStage(featureIds, attributes);
 
+    // ──────────────────────────────────────────────────────────────────────
+    // BENTLEY_materials_planar_fill: Feature-ID pre-pass output.
+    //
+    // When HAS_PLANAR_FILL_ID_PASS is defined this command is being rendered
+    // into the planar fill ID framebuffer.  Non-behind planar geometry writes
+    // its feature ID + 1 into the R channel (0 = no feature) and returns.
+    // No material / lighting / post-process stages are needed.
+    // ──────────────────────────────────────────────────────────────────────
+    #ifdef HAS_PLANAR_FILL_ID_PASS
+    if (u_isPlanarFillIdPass) {
+        float fid = float(featureIds.PLANAR_FILL_FEATURE_ID) + FEATURE_ID_OFFSET;
+        out_FragColor = vec4(fid, 0.0, 0.0, 1.0);
+        // Still need to write log depth so the depth buffer is correct.
+        #ifdef LOG_DEPTH
+        czm_writeLogDepth();
+        #endif
+        return;
+    }
+    #endif
+
     Metadata metadata;
     MetadataClass metadataClass;
     MetadataStatistics metadataStatistics;
@@ -145,6 +192,12 @@ void main()
     #ifdef HAS_EDGE_VISIBILITY
     edgeVisibilityStage(color, featureIds);
     edgeDetectionStage(color, featureIds);
+    // Edge-pass fragments rasterize the edge band itself. Flag them so the
+    // snap payload (see Scene#snap) can distinguish edges from surfaces;
+    // surface fragments leave isEdge false.
+    if (u_isEdgePass) {
+        isEdge = true;
+    }
     #endif
 
     #endif
@@ -152,5 +205,57 @@ void main()
     //========================================================================
 
     out_FragColor = color;
+
+    // ──────────────────────────────────────────────────────────────────────
+    // Explicit log-depth write.
+    //
+    // DerivedCommand.getLogDepthShaderProgram auto-wraps only when the raw
+    // source does NOT already mention czm_writeLogDepth.  We mention it
+    // above in the HAS_PLANAR_FILL_ID_PASS block, so we must also handle
+    // the normal code path ourselves.  The LOG_DEPTH define is injected by
+    // that same auto-wrapper, so this block is active exactly when needed.
+    // ──────────────────────────────────────────────────────────────────────
+    #ifdef LOG_DEPTH
+    czm_writeLogDepth();
+    #endif
+
+    // ──────────────────────────────────────────────────────────────────────
+    // BENTLEY_materials_planar_fill: Proportional depth adjustment.
+    //
+    // Per the spec, planar primitives must render in front of non-planar
+    // geometry. We use proportional depth scaling (similar to edge visibility)
+    // which scales naturally with logarithmic depth at all viewing distances.
+    //
+    // ──────────────────────────────────────────────────────────────────────
+    #ifdef HAS_PLANAR_FILL_DEPTH
+    gl_FragDepth *= PLANAR_DEPTH_PULL;
+    #endif
+
+    // ──────────────────────────────────────────────────────────────────────
+    // BENTLEY_materials_planar_fill: Behind fill depth adjustment.
+    //
+    // After the proportional depth pull has been applied, sample the planar
+    // fill ID texture. If the pixel already belongs to the same feature,
+    // apply a small proportional push so this "behind" fill sits behind its
+    // non-behind sibling. If the pixel has no stored feature, the base pull
+    // still keeps us in front of non-planar geometry.
+    //
+    // ──────────────────────────────────────────────────────────────────────
+    #ifdef HAS_PLANAR_FILL_BEHIND
+    {
+        vec2 screenCoord = gl_FragCoord.xy / czm_viewport.zw;
+        float storedEncoded = texture(czm_planarFillIdTexture, screenCoord).r;
+        float storedFeatureId = storedEncoded - FEATURE_ID_OFFSET;
+        float myFeatureId = float(featureIds.PLANAR_FILL_FEATURE_ID);
+
+        // storedFeatureId < 0 means "no planar fill at this pixel".
+        if (storedFeatureId >= 0.0 && abs(storedFeatureId - myFeatureId) < FEATURE_ID_TOLERANCE) {
+            // Proportional push: multiply by >1 to move away from camera.
+            // Net effect: PLANAR_DEPTH_PULL * BEHIND_DEPTH_PUSH ≈ 0.9997,
+            // still in front of non-planar but behind same-feature non-behind fills.
+            gl_FragDepth *= BEHIND_DEPTH_PUSH;
+        }
+    }
+    #endif
 }
 

package/Source/Shaders/Model/ModelFS.js

@@ -2,6 +2,29 @@
 export default "\n\
 precision highp float;\n\
 \n\
+// ──────────────────────────────────────────────────────────────────────\n\
+// BENTLEY_materials_planar_fill constants\n\
+//\n\
+// These factors scale gl_FragDepth AFTER czm_writeLogDepth has run, so\n\
+// they are proportional offsets in log-depth space. The corresponding\n\
+// eye-space offset therefore varies with the fragment's distance from\n\
+// the camera (growing with distance). This is the intended behavior: it\n\
+// matches the proportional depth comparison tolerance used by the edge\n\
+// visibility system, so fills and edges stay consistently ordered at all\n\
+// viewing distances.\n\
+// ──────────────────────────────────────────────────────────────────────\n\
+// Depth pull factor for all planar fills: scales log depth by 0.9995,\n\
+// i.e. a 0.05% pull toward the camera in log-depth space.\n\
+const float PLANAR_DEPTH_PULL = 0.9995;\n\
+// Depth push factor for behind fills: scales log depth by 1.0002, i.e. a\n\
+// 0.02% push away from the camera in log-depth space, so behind fills sit\n\
+// behind same-object siblings.\n\
+const float BEHIND_DEPTH_PUSH = 1.0002;\n\
+// Tolerance for comparing feature IDs stored as floats (integer equality).\n\
+const float FEATURE_ID_TOLERANCE = 0.5;\n\
+// Offset added to feature IDs so 0 means \"no planar fill\" in the texture.\n\
+const float FEATURE_ID_OFFSET = 1.0;\n\
+\n\
 czm_modelMaterial defaultModelMaterial()\n\
 {\n\
     czm_modelMaterial material;\n\
@@ -41,6 +64,10 @@ void lineStyleStage()\n\
 \n\
 SelectedFeature selectedFeature;\n\
 \n\
+// Set by edge-pass fragments below; consumed by the snapId expression built\n\
+// in PickingPipelineStage (see Scene#snap).\n\
+bool isEdge = false;\n\
+\n\
 void main()\n\
 {\n\
     #if defined(PRIMITIVE_TYPE_POINTS) && defined(HAS_POINT_DIAMETER)\n\
@@ -69,6 +96,26 @@ void main()\n\
 \n\
     FeatureIds featureIds;\n\
     featureIdStage(featureIds, attributes);\n\
+\n\
+    // ──────────────────────────────────────────────────────────────────────\n\
+    // BENTLEY_materials_planar_fill: Feature-ID pre-pass output.\n\
+    //\n\
+    // When HAS_PLANAR_FILL_ID_PASS is defined this command is being rendered\n\
+    // into the planar fill ID framebuffer.  Non-behind planar geometry writes\n\
+    // its feature ID + 1 into the R channel (0 = no feature) and returns.\n\
+    // No material / lighting / post-process stages are needed.\n\
+    // ──────────────────────────────────────────────────────────────────────\n\
+    #ifdef HAS_PLANAR_FILL_ID_PASS\n\
+    if (u_isPlanarFillIdPass) {\n\
+        float fid = float(featureIds.PLANAR_FILL_FEATURE_ID) + FEATURE_ID_OFFSET;\n\
+        out_FragColor = vec4(fid, 0.0, 0.0, 1.0);\n\
+        // Still need to write log depth so the depth buffer is correct.\n\
+        #ifdef LOG_DEPTH\n\
+        czm_writeLogDepth();\n\
+        #endif\n\
+        return;\n\
+    }\n\
+    #endif\n\
 \n\
     Metadata metadata;\n\
     MetadataClass metadataClass;\n\
@@ -146,6 +193,12 @@ void main()\n\
     #ifdef HAS_EDGE_VISIBILITY\n\
     edgeVisibilityStage(color, featureIds);\n\
     edgeDetectionStage(color, featureIds);\n\
+    // Edge-pass fragments rasterize the edge band itself. Flag them so the\n\
+    // snap payload (see Scene#snap) can distinguish edges from surfaces;\n\
+    // surface fragments leave isEdge false.\n\
+    if (u_isEdgePass) {\n\
+        isEdge = true;\n\
+    }\n\
     #endif\n\
 \n\
     #endif\n\
@@ -153,6 +206,58 @@ void main()\n\
     //========================================================================\n\
 \n\
     out_FragColor = color;\n\
+\n\
+    // ──────────────────────────────────────────────────────────────────────\n\
+    // Explicit log-depth write.\n\
+    //\n\
+    // DerivedCommand.getLogDepthShaderProgram auto-wraps only when the raw\n\
+    // source does NOT already mention czm_writeLogDepth.  We mention it\n\
+    // above in the HAS_PLANAR_FILL_ID_PASS block, so we must also handle\n\
+    // the normal code path ourselves.  The LOG_DEPTH define is injected by\n\
+    // that same auto-wrapper, so this block is active exactly when needed.\n\
+    // ──────────────────────────────────────────────────────────────────────\n\
+    #ifdef LOG_DEPTH\n\
+    czm_writeLogDepth();\n\
+    #endif\n\
+\n\
+    // ──────────────────────────────────────────────────────────────────────\n\
+    // BENTLEY_materials_planar_fill: Proportional depth adjustment.\n\
+    //\n\
+    // Per the spec, planar primitives must render in front of non-planar\n\
+    // geometry. We use proportional depth scaling (similar to edge visibility)\n\
+    // which scales naturally with logarithmic depth at all viewing distances.\n\
+    //\n\
+    // ──────────────────────────────────────────────────────────────────────\n\
+    #ifdef HAS_PLANAR_FILL_DEPTH\n\
+    gl_FragDepth *= PLANAR_DEPTH_PULL;\n\
+    #endif\n\
+\n\
+    // ──────────────────────────────────────────────────────────────────────\n\
+    // BENTLEY_materials_planar_fill: Behind fill depth adjustment.\n\
+    //\n\
+    // After the proportional depth pull has been applied, sample the planar\n\
+    // fill ID texture. If the pixel already belongs to the same feature,\n\
+    // apply a small proportional push so this \"behind\" fill sits behind its\n\
+    // non-behind sibling. If the pixel has no stored feature, the base pull\n\
+    // still keeps us in front of non-planar geometry.\n\
+    //\n\
+    // ──────────────────────────────────────────────────────────────────────\n\
+    #ifdef HAS_PLANAR_FILL_BEHIND\n\
+    {\n\
+        vec2 screenCoord = gl_FragCoord.xy / czm_viewport.zw;\n\
+        float storedEncoded = texture(czm_planarFillIdTexture, screenCoord).r;\n\
+        float storedFeatureId = storedEncoded - FEATURE_ID_OFFSET;\n\
+        float myFeatureId = float(featureIds.PLANAR_FILL_FEATURE_ID);\n\
+\n\
+        // storedFeatureId < 0 means \"no planar fill at this pixel\".\n\
+        if (storedFeatureId >= 0.0 && abs(storedFeatureId - myFeatureId) < FEATURE_ID_TOLERANCE) {\n\
+            // Proportional push: multiply by >1 to move away from camera.\n\
+            // Net effect: PLANAR_DEPTH_PULL * BEHIND_DEPTH_PUSH ≈ 0.9997,\n\
+            // still in front of non-planar but behind same-feature non-behind fills.\n\
+            gl_FragDepth *= BEHIND_DEPTH_PUSH;\n\
+        }\n\
+    }\n\
+    #endif\n\
 }\n\
 \n\
 ";

package/Source/Shaders/PolylineShadowVolumeFS.glsl

@@ -34,6 +34,20 @@ void main(void)
     float distanceFromStart = czm_planeDistance(v_startPlaneNormalEcAndHalfWidth.xyz, -dot(ecStart, v_startPlaneNormalEcAndHalfWidth.xyz), eyeCoordinate.xyz);
     float distanceFromEnd = czm_planeDistance(v_endPlaneNormalEcAndBatchId.xyz, -dot(v_endEcAndStartEcX.xyz, v_endPlaneNormalEcAndBatchId.xyz), eyeCoordinate.xyz);
 
+    // HZ patch: in Columbus View ground polylines are tessellated at a fixed
+    // ground distance (granularity, ~10 km), so pulling the camera back makes a
+    // segment shorter than a pixel while the eye point reconstructed from the
+    // globe depth stays only accurate to about a pixel. Both miter planes then
+    // land on the same fragment and reject it, and once the whole line is
+    // sub-pixel it disappears entirely (visible from ~16M m altitude, worst at
+    // the antimeridian seam). Widen the miter planes by a pixel in CV only;
+    // neighbouring segments already overlap there, so the joins do not change.
+    if (czm_sceneMode == czm_sceneModeColumbusView) {
+        float miterTolerance = czm_metersPerPixel(eyeCoordinate);
+        distanceFromStart += miterTolerance;
+        distanceFromEnd += miterTolerance;
+    }
+
     if (abs(widthwiseDistance) > halfMaxWidth || distanceFromStart < 0.0 || distanceFromEnd < 0.0) {
 #ifdef DEBUG_SHOW_VOLUME
         out_FragColor = vec4(1.0, 0.0, 0.0, 0.5);

package/Source/Shaders/PolylineShadowVolumeFS.js

@@ -34,6 +34,20 @@ void main(void)\n\
     // Check eye coordinate against the mitering planes\n\
     float distanceFromStart = czm_planeDistance(v_startPlaneNormalEcAndHalfWidth.xyz, -dot(ecStart, v_startPlaneNormalEcAndHalfWidth.xyz), eyeCoordinate.xyz);\n\
     float distanceFromEnd = czm_planeDistance(v_endPlaneNormalEcAndBatchId.xyz, -dot(v_endEcAndStartEcX.xyz, v_endPlaneNormalEcAndBatchId.xyz), eyeCoordinate.xyz);\n\
+\n\
+    // HZ patch: in Columbus View ground polylines are tessellated at a fixed\n\
+    // ground distance (granularity, ~10 km), so pulling the camera back makes a\n\
+    // segment shorter than a pixel while the eye point reconstructed from the\n\
+    // globe depth stays only accurate to about a pixel. Both miter planes then\n\
+    // land on the same fragment and reject it, and once the whole line is\n\
+    // sub-pixel it disappears entirely (visible from ~16M m altitude, worst at\n\
+    // the antimeridian seam). Widen the miter planes by a pixel in CV only;\n\
+    // neighbouring segments already overlap there, so the joins do not change.\n\
+    if (czm_sceneMode == czm_sceneModeColumbusView) {\n\
+        float miterTolerance = czm_metersPerPixel(eyeCoordinate);\n\
+        distanceFromStart += miterTolerance;\n\
+        distanceFromEnd += miterTolerance;\n\
+    }\n\
 \n\
     if (abs(widthwiseDistance) > halfMaxWidth || distanceFromStart < 0.0 || distanceFromEnd < 0.0) {\n\
 #ifdef DEBUG_SHOW_VOLUME\n\

package/Source/Shaders/RestoreDepth.glsl

@@ -0,0 +1,8 @@
+uniform highp sampler2D u_depthTexture;
+
+in vec2 v_textureCoordinates;
+
+void main()
+{
+    gl_FragDepth = czm_unpackDepth(texture(u_depthTexture, v_textureCoordinates));
+}

package/Source/Shaders/RestoreDepth.js

@@ -0,0 +1,10 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "uniform highp sampler2D u_depthTexture;\n\
+\n\
+in vec2 v_textureCoordinates;\n\
+\n\
+void main()\n\
+{\n\
+    gl_FragDepth = czm_unpackDepth(texture(u_depthTexture, v_textureCoordinates));\n\
+}\n\
+";