@cesium/engine 26.1.0 → 26.3.0

package/Source/Shaders/GlobeFS.glsl

@@ -77,18 +77,12 @@ uniform mat4 u_clippingPlanesMatrix;
 uniform vec4 u_clippingPlanesEdgeStyle;
 #endif
 
-#ifdef ENABLE_CLIPPING_POLYGONS
-uniform highp sampler2D u_clippingDistance;
-in vec2 v_clippingPosition;
-flat in int v_regionIndex;
-#endif
-
 #if defined(GROUND_ATMOSPHERE) || defined(FOG) && defined(DYNAMIC_ATMOSPHERE_LIGHTING) && (defined(ENABLE_VERTEX_LIGHTING) || defined(ENABLE_DAYNIGHT_SHADING))
 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 +110,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
@@ -457,9 +451,16 @@ void main()
 #endif
 
 #ifdef ENABLE_CLIPPING_POLYGONS
-    vec2 clippingPosition = v_clippingPosition;
-    int regionIndex = v_regionIndex;
-    clipPolygons(u_clippingDistance, CLIPPING_POLYGON_REGIONS_LENGTH, clippingPosition, regionIndex);
+    bool insideAny = vectorClip(v_textureCoordinates.xy);
+    #ifdef CLIPPING_INVERSE
+        if (!insideAny) {
+            discard;
+        }
+    #else
+        if (insideAny) {
+            discard;
+        }
+    #endif
 #endif
 
 #ifdef HIGHLIGHT_FILL_TILE
@@ -576,11 +577,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

@@ -78,18 +78,12 @@ uniform mat4 u_clippingPlanesMatrix;\n\
 uniform vec4 u_clippingPlanesEdgeStyle;\n\
 #endif\n\
 \n\
-#ifdef ENABLE_CLIPPING_POLYGONS\n\
-uniform highp sampler2D u_clippingDistance;\n\
-in vec2 v_clippingPosition;\n\
-flat in int v_regionIndex;\n\
-#endif\n\
-\n\
 #if defined(GROUND_ATMOSPHERE) || defined(FOG) && defined(DYNAMIC_ATMOSPHERE_LIGHTING) && (defined(ENABLE_VERTEX_LIGHTING) || defined(ENABLE_DAYNIGHT_SHADING))\n\
 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 +111,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\
@@ -458,9 +452,16 @@ void main()\n\
 #endif\n\
 \n\
 #ifdef ENABLE_CLIPPING_POLYGONS\n\
-    vec2 clippingPosition = v_clippingPosition;\n\
-    int regionIndex = v_regionIndex;\n\
-    clipPolygons(u_clippingDistance, CLIPPING_POLYGON_REGIONS_LENGTH, clippingPosition, regionIndex);\n\
+    bool insideAny = vectorClip(v_textureCoordinates.xy);\n\
+    #ifdef CLIPPING_INVERSE\n\
+        if (!insideAny) {\n\
+            discard;\n\
+        }\n\
+    #else\n\
+        if (insideAny) {\n\
+            discard;\n\
+        }\n\
+    #endif\n\
 #endif\n\
 \n\
 #ifdef HIGHLIGHT_FILL_TILE\n\
@@ -577,11 +578,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\

package/Source/Shaders/GlobeVS.glsl

@@ -46,12 +46,6 @@ out vec3 v_atmosphereMieColor;
 out float v_atmosphereOpacity;
 #endif
 
-#ifdef ENABLE_CLIPPING_POLYGONS
-uniform highp sampler2D u_clippingExtents;
-out vec2 v_clippingPosition;
-flat out int v_regionIndex;
-#endif
-
 // These functions are generated at runtime.
 vec4 getPosition(vec3 position, float height, vec2 textureCoordinates);
 float get2DYPositionFraction(vec2 textureCoordinates);
@@ -214,32 +208,6 @@ void main()
     v_normalEC = czm_normal3D * v_normalMC;
 #endif
 
-#ifdef ENABLE_CLIPPING_POLYGONS
-    vec2 sphericalLatLong = czm_approximateSphericalCoordinates(position3DWC);
-    sphericalLatLong.y = czm_branchFreeTernary(sphericalLatLong.y < czm_pi, sphericalLatLong.y, sphericalLatLong.y - czm_twoPi);
-    
-    vec2 minDistance = vec2(czm_infinity);
-    v_clippingPosition = vec2(czm_infinity);
-    v_regionIndex = -1;
-
-    for (int regionIndex = 0; regionIndex < CLIPPING_POLYGON_REGIONS_LENGTH; regionIndex++) {
-        vec4 extents = unpackClippingExtents(u_clippingExtents, regionIndex);
-        vec2 rectUv = (sphericalLatLong.yx - extents.yx) * extents.wz;
-
-        vec2 clamped = clamp(rectUv, vec2(0.0), vec2(1.0));
-        vec2 distance = abs(rectUv - clamped) * extents.wz;
-
-        float threshold = 0.01;
-        if (minDistance.x > distance.x || minDistance.y > distance.y) {
-            minDistance = distance;
-            v_clippingPosition = rectUv;
-            if (rectUv.x > threshold && rectUv.y > threshold && rectUv.x < 1.0 - threshold && rectUv.y < 1.0 - threshold) {
-                v_regionIndex = regionIndex;
-            }
-        }
-    }
-#endif
-
 #if defined(FOG) || (defined(GROUND_ATMOSPHERE) && !defined(PER_FRAGMENT_GROUND_ATMOSPHERE))
 
     bool dynamicLighting = false;

package/Source/Shaders/GlobeVS.js

@@ -47,12 +47,6 @@ out vec3 v_atmosphereMieColor;\n\
 out float v_atmosphereOpacity;\n\
 #endif\n\
 \n\
-#ifdef ENABLE_CLIPPING_POLYGONS\n\
-uniform highp sampler2D u_clippingExtents;\n\
-out vec2 v_clippingPosition;\n\
-flat out int v_regionIndex;\n\
-#endif\n\
-\n\
 // These functions are generated at runtime.\n\
 vec4 getPosition(vec3 position, float height, vec2 textureCoordinates);\n\
 float get2DYPositionFraction(vec2 textureCoordinates);\n\
@@ -215,32 +209,6 @@ void main()\n\
     v_normalEC = czm_normal3D * v_normalMC;\n\
 #endif\n\
 \n\
-#ifdef ENABLE_CLIPPING_POLYGONS\n\
-    vec2 sphericalLatLong = czm_approximateSphericalCoordinates(position3DWC);\n\
-    sphericalLatLong.y = czm_branchFreeTernary(sphericalLatLong.y < czm_pi, sphericalLatLong.y, sphericalLatLong.y - czm_twoPi);\n\
-    \n\
-    vec2 minDistance = vec2(czm_infinity);\n\
-    v_clippingPosition = vec2(czm_infinity);\n\
-    v_regionIndex = -1;\n\
-\n\
-    for (int regionIndex = 0; regionIndex < CLIPPING_POLYGON_REGIONS_LENGTH; regionIndex++) {\n\
-        vec4 extents = unpackClippingExtents(u_clippingExtents, regionIndex);\n\
-        vec2 rectUv = (sphericalLatLong.yx - extents.yx) * extents.wz;\n\
-\n\
-        vec2 clamped = clamp(rectUv, vec2(0.0), vec2(1.0));\n\
-        vec2 distance = abs(rectUv - clamped) * extents.wz;\n\
-\n\
-        float threshold = 0.01;\n\
-        if (minDistance.x > distance.x || minDistance.y > distance.y) {\n\
-            minDistance = distance;\n\
-            v_clippingPosition = rectUv;\n\
-            if (rectUv.x > threshold && rectUv.y > threshold && rectUv.x < 1.0 - threshold && rectUv.y < 1.0 - threshold) {\n\
-                v_regionIndex = regionIndex;\n\
-            }\n\
-        }\n\
-    }\n\
-#endif\n\
-\n\
 #if defined(FOG) || (defined(GROUND_ATMOSPHERE) && !defined(PER_FRAGMENT_GROUND_ATMOSPHERE))\n\
 \n\
     bool dynamicLighting = false;\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/ModelClippingPolygonsStageFS.glsl

@@ -1,6 +1,18 @@
 void modelClippingPolygonsStage()
 {
-    vec2 clippingPosition = v_clippingPosition;
-    int regionIndex = v_regionIndex;
-    czm_clipPolygons(model_clippingDistance, CLIPPING_POLYGON_REGIONS_LENGTH, clippingPosition, regionIndex);
+    // The lookup uv was computed per vertex in the vertex stage and
+    // interpolated across the primitive, so the fragment shader only samples it.
+    bool insideAny = vectorClip(v_clippingUv);
+
+#ifdef CLIPPING_INVERSE
+    if (!insideAny)
+    {
+        discard;
+    }
+#else
+    if (insideAny)
+    {
+        discard;
+    }
+#endif
 }

package/Source/Shaders/Model/ModelClippingPolygonsStageFS.js

@@ -1,8 +1,20 @@
 //This file is automatically rebuilt by the Cesium build process.
 export default "void modelClippingPolygonsStage()\n\
 {\n\
-    vec2 clippingPosition = v_clippingPosition;\n\
-    int regionIndex = v_regionIndex;\n\
-    czm_clipPolygons(model_clippingDistance, CLIPPING_POLYGON_REGIONS_LENGTH, clippingPosition, regionIndex);\n\
+    // The lookup uv was computed per vertex in the vertex stage and\n\
+    // interpolated across the primitive, so the fragment shader only samples it.\n\
+    bool insideAny = vectorClip(v_clippingUv);\n\
+\n\
+#ifdef CLIPPING_INVERSE\n\
+    if (!insideAny)\n\
+    {\n\
+        discard;\n\
+    }\n\
+#else\n\
+    if (insideAny)\n\
+    {\n\
+        discard;\n\
+    }\n\
+#endif\n\
 }\n\
 ";

package/Source/Shaders/Model/ModelClippingPolygonsStageVS.glsl

@@ -1,27 +1,23 @@
-void modelClippingPolygonsStage(ProcessedAttributes attributes)
+/**
+ * This vertex shader derives each vertex's UV coordinate within the model's clipping rectangle (its ellipsoid footprint).
+ * This UV is a normalized vec2, where [0,1] spans the rectangle. The fragment shader then compares each fragment's uv against the clipping polygons,
+ * whose positions live in the same uv space. See {@link ModelClippingPolygonsStageFS.glsl}.
+ *
+ * To get this uv, we need each vertex's geodetic (lon, lat), normalized against the model's rectangle.
+ * What makes this complicated is precision: we *cannot* use v_positionWC, because it only has 32-bit precision and is too large to be represented precisely.
+ * (Moreover, even representing v_positionWC with hi/lo components to emulate double precision, we could not perform the trig and other ops needed to derive lat/lon.)
+ * Instead, we use v_positionEC, and let {@link czm_eyeToCartographicDelta} compute a geodetic delta (long, lat) between the camera and vertex. This delta is a smaller quantity (and gets smaller and more precise as we zoom in).
+ * Then, we can combine this delta with the camera's own UV coordinate within the model's rectangle to obtain the vertex's uv coordinate.
+ *
+ * Ultimately, all this shader does is some geometry to obtain the vertex's relative position within the bounds of the model's geodetic rectangle.
+ * The complexity arises from doing so in a way that preserves precision.
+ */
+void modelClippingPolygonsStage()
 {
-    vec2 sphericalLatLong = czm_approximateSphericalCoordinates(v_positionWC);
-    sphericalLatLong.y = czm_branchFreeTernary(sphericalLatLong.y < czm_pi, sphericalLatLong.y, sphericalLatLong.y - czm_twoPi);
+    // (We don't need the height component)
+    vec2 delta = czm_eyeToCartographicDelta(v_positionEC).xy;
 
-    vec2 minDistance = vec2(czm_infinity);
-    v_regionIndex = -1;
-    v_clippingPosition = vec2(czm_infinity);
-
-    for (int regionIndex = 0; regionIndex < CLIPPING_POLYGON_REGIONS_LENGTH; regionIndex++) {
-        vec4 extents = czm_unpackClippingExtents(model_clippingExtents, regionIndex);
-        vec2 rectUv = (sphericalLatLong.yx - extents.yx) * extents.wz;
-
-        vec2 clamped = clamp(rectUv, vec2(0.0), vec2(1.0));
-        vec2 distance = abs(rectUv - clamped) * extents.wz;
-        
-        if (minDistance.x > distance.x || minDistance.y > distance.y) {
-            minDistance = distance;
-            v_clippingPosition = rectUv;
-        }
-
-        float threshold = 0.01;
-        if (rectUv.x > threshold && rectUv.y > threshold && rectUv.x < 1.0 - threshold && rectUv.y < 1.0 - threshold) {
-            v_regionIndex = regionIndex;
-        }
-    }
+    // Express the vertex's position within the model's rectangle as a normalized uv coordinate, by adding the camera's uv and scaling by the rectangle's size.
+    // Since the camera's UV is computed on the CPU in double precision, and gets more precise as one zooms in, this ensures good precision on the vertex's uv.
+    v_clippingUv = u_clippingCameraUv + delta * u_clippingRectangleInverseSize;
 }

package/Source/Shaders/Model/ModelClippingPolygonsStageVS.js

@@ -1,29 +1,25 @@
 //This file is automatically rebuilt by the Cesium build process.
-export default "void modelClippingPolygonsStage(ProcessedAttributes attributes)\n\
+export default "/**\n\
+ * This vertex shader derives each vertex's UV coordinate within the model's clipping rectangle (its ellipsoid footprint).\n\
+ * This UV is a normalized vec2, where [0,1] spans the rectangle. The fragment shader then compares each fragment's uv against the clipping polygons,\n\
+ * whose positions live in the same uv space. See {@link ModelClippingPolygonsStageFS.glsl}.\n\
+ *\n\
+ * To get this uv, we need each vertex's geodetic (lon, lat), normalized against the model's rectangle.\n\
+ * What makes this complicated is precision: we *cannot* use v_positionWC, because it only has 32-bit precision and is too large to be represented precisely.\n\
+ * (Moreover, even representing v_positionWC with hi/lo components to emulate double precision, we could not perform the trig and other ops needed to derive lat/lon.)\n\
+ * Instead, we use v_positionEC, and let {@link czm_eyeToCartographicDelta} compute a geodetic delta (long, lat) between the camera and vertex. This delta is a smaller quantity (and gets smaller and more precise as we zoom in).\n\
+ * Then, we can combine this delta with the camera's own UV coordinate within the model's rectangle to obtain the vertex's uv coordinate.\n\
+ *\n\
+ * Ultimately, all this shader does is some geometry to obtain the vertex's relative position within the bounds of the model's geodetic rectangle.\n\
+ * The complexity arises from doing so in a way that preserves precision.\n\
+ */\n\
+void modelClippingPolygonsStage()\n\
 {\n\
-    vec2 sphericalLatLong = czm_approximateSphericalCoordinates(v_positionWC);\n\
-    sphericalLatLong.y = czm_branchFreeTernary(sphericalLatLong.y < czm_pi, sphericalLatLong.y, sphericalLatLong.y - czm_twoPi);\n\
+    // (We don't need the height component)\n\
+    vec2 delta = czm_eyeToCartographicDelta(v_positionEC).xy;\n\
 \n\
-    vec2 minDistance = vec2(czm_infinity);\n\
-    v_regionIndex = -1;\n\
-    v_clippingPosition = vec2(czm_infinity);\n\
-\n\
-    for (int regionIndex = 0; regionIndex < CLIPPING_POLYGON_REGIONS_LENGTH; regionIndex++) {\n\
-        vec4 extents = czm_unpackClippingExtents(model_clippingExtents, regionIndex);\n\
-        vec2 rectUv = (sphericalLatLong.yx - extents.yx) * extents.wz;\n\
-\n\
-        vec2 clamped = clamp(rectUv, vec2(0.0), vec2(1.0));\n\
-        vec2 distance = abs(rectUv - clamped) * extents.wz;\n\
-        \n\
-        if (minDistance.x > distance.x || minDistance.y > distance.y) {\n\
-            minDistance = distance;\n\
-            v_clippingPosition = rectUv;\n\
-        }\n\
-\n\
-        float threshold = 0.01;\n\
-        if (rectUv.x > threshold && rectUv.y > threshold && rectUv.x < 1.0 - threshold && rectUv.y < 1.0 - threshold) {\n\
-            v_regionIndex = regionIndex;\n\
-        }\n\
-    }\n\
+    // Express the vertex's position within the model's rectangle as a normalized uv coordinate, by adding the camera's uv and scaling by the rectangle's size.\n\
+    // Since the camera's UV is computed on the CPU in double precision, and gets more precise as one zooms in, this ensures good precision on the vertex's uv.\n\
+    v_clippingUv = u_clippingCameraUv + delta * u_clippingRectangleInverseSize;\n\
 }\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;
@@ -130,6 +177,10 @@ void main()
     modelClippingPolygonsStage();
     #endif
 
+    #ifdef HAS_VECTOR_LOOKUP
+    modelVectorLookupStage(color);
+    #endif
+
     //========================================================================
     // When not picking metadata START
     #ifndef METADATA_PICKING_ENABLED
@@ -145,6 +196,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 +209,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
 }