@cesium/engine 26.1.0 → 26.2.0

package/Source/Shaders/Builtin/Constants/passCesium3DTileClassification.glsl

@@ -6,4 +6,4 @@
  *
  * @see czm_pass
  */
-const float czm_passCesium3DTileClassification = 6.0;
+const float czm_passCesium3DTileClassification = 7.0;

package/Source/Shaders/Builtin/Constants/passCesium3DTileClassification.js

@@ -7,5 +7,5 @@ export default "/**\n\
  *\n\
  * @see czm_pass\n\
  */\n\
-const float czm_passCesium3DTileClassification = 6.0;\n\
+const float czm_passCesium3DTileClassification = 7.0;\n\
 ";

package/Source/Shaders/Builtin/Constants/passCesium3DTileClassificationIgnoreShow.glsl

@@ -6,4 +6,4 @@
  *
  * @see czm_pass
  */
-const float czm_passCesium3DTileClassificationIgnoreShow = 7.0;
+const float czm_passCesium3DTileClassificationIgnoreShow = 8.0;

package/Source/Shaders/Builtin/Constants/passCesium3DTileClassificationIgnoreShow.js

@@ -7,5 +7,5 @@ export default "/**\n\
  *\n\
  * @see czm_pass\n\
  */\n\
-const float czm_passCesium3DTileClassificationIgnoreShow = 7.0;\n\
+const float czm_passCesium3DTileClassificationIgnoreShow = 8.0;\n\
 ";

package/Source/Shaders/Builtin/Constants/passCesium3DTilePlanarFillId.glsl

@@ -0,0 +1,9 @@
+/**
+ * The automatic GLSL constant for {@link Pass#CESIUM_3D_TILE_PLANAR_FILL_ID}
+ *
+ * @name czm_passCesium3DTilePlanarFillId
+ * @glslConstant
+ *
+ * @see czm_pass
+ */
+const float czm_passCesium3DTilePlanarFillId = 5.0;

package/Source/Shaders/Builtin/Constants/passCesium3DTilePlanarFillId.js

@@ -0,0 +1,11 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "/**\n\
+ * The automatic GLSL constant for {@link Pass#CESIUM_3D_TILE_PLANAR_FILL_ID}\n\
+ *\n\
+ * @name czm_passCesium3DTilePlanarFillId\n\
+ * @glslConstant\n\
+ *\n\
+ * @see czm_pass\n\
+ */\n\
+const float czm_passCesium3DTilePlanarFillId = 5.0;\n\
+";

package/Source/Shaders/Builtin/Constants/passClassification.glsl

@@ -6,4 +6,4 @@
  *
  * @see czm_pass
  */
-const float czm_passClassification = 7.0;
+const float czm_passClassification = 8.0;

package/Source/Shaders/Builtin/Constants/passClassification.js

@@ -7,5 +7,5 @@ export default "/**\n\
  *\n\
  * @see czm_pass\n\
  */\n\
-const float czm_passClassification = 7.0;\n\
+const float czm_passClassification = 8.0;\n\
 ";

package/Source/Shaders/Builtin/Constants/passGaussianSplats.glsl

@@ -6,4 +6,4 @@
  *
  * @see czm_pass
  */
-const float czm_passGaussianSplats = 11.0;
+const float czm_passGaussianSplats = 12.0;

package/Source/Shaders/Builtin/Constants/passGaussianSplats.js

@@ -7,5 +7,5 @@ export default "/**\n\
  *\n\
  * @see czm_pass\n\
  */\n\
-const float czm_passGaussianSplats = 11.0;\n\
+const float czm_passGaussianSplats = 12.0;\n\
 ";

package/Source/Shaders/Builtin/Constants/passOpaque.glsl

@@ -6,4 +6,4 @@
  *
  * @see czm_pass
  */
-const float czm_passOpaque = 8.0;
+const float czm_passOpaque = 9.0;

package/Source/Shaders/Builtin/Constants/passOpaque.js

@@ -7,5 +7,5 @@ export default "/**\n\
  *\n\
  * @see czm_pass\n\
  */\n\
-const float czm_passOpaque = 8.0;\n\
+const float czm_passOpaque = 9.0;\n\
 ";

package/Source/Shaders/Builtin/Constants/passTranslucent.glsl

@@ -6,4 +6,4 @@
  *
  * @see czm_pass
  */
-const float czm_passTranslucent = 9.0;
+const float czm_passTranslucent = 10.0;

package/Source/Shaders/Builtin/Constants/passTranslucent.js

@@ -7,5 +7,5 @@ export default "/**\n\
  *\n\
  * @see czm_pass\n\
  */\n\
-const float czm_passTranslucent = 9.0;\n\
+const float czm_passTranslucent = 10.0;\n\
 ";

package/Source/Shaders/Builtin/Constants/passVoxels.glsl

@@ -6,4 +6,4 @@
  *
  * @see czm_pass
  */
-const float czm_passVoxels = 10.0;
+const float czm_passVoxels = 11.0;

package/Source/Shaders/Builtin/Constants/passVoxels.js

@@ -7,5 +7,5 @@ export default "/**\n\
  *\n\
  * @see czm_pass\n\
  */\n\
-const float czm_passVoxels = 10.0;\n\
+const float czm_passVoxels = 11.0;\n\
 ";

package/Source/Shaders/Builtin/CzmBuiltins.js

@@ -16,6 +16,7 @@ import czm_passCesium3DTileClassification from './Constants/passCesium3DTileClas
 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'
@@ -160,6 +161,7 @@ export default {
     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

@@ -88,7 +88,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
@@ -116,8 +116,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
@@ -576,11 +576,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
 

package/Source/Shaders/GlobeFS.js

@@ -89,7 +89,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\
@@ -117,8 +117,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\
@@ -577,11 +577,15 @@ void main()\n\
     }\n\
 #endif\n\
 \n\
+#ifdef HAS_VECTOR_LAYER\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\

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