@hztxi/cesium-engine 25.0.7 → 26.2.2

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/VectorCommon.glsl

@@ -0,0 +1,178 @@
+uniform highp sampler2D u_vectorSegmentTexture;
+uniform highp sampler2D u_vectorWidthTexture;
+uniform highp sampler2D u_vectorColorTexture;
+uniform highp sampler2D u_vectorSegmentPrimitiveIndicesTexture;
+uniform highp sampler2D u_vectorGridCellIndicesTexture;
+uniform highp sampler2D u_vectorPolygonEdgeTexture;
+uniform highp sampler2D u_vectorPolygonEdgePrimitiveIndicesTexture;
+uniform highp sampler2D u_vectorPolygonGridCellIndicesTexture;
+
+// UV-space offset from the closest point on the segment to p.
+vec2 vectorOffsetToLine(vec2 p, vec4 line)
+{
+    vec2 a = line.xy;
+    vec2 b = line.zw;
+    vec2 ab = b - a;
+    float abLengthSquared = dot(ab, ab);
+    if (abLengthSquared < 1.0e-8)
+    {
+        return p - a;
+    }
+    float t = clamp(dot(p - a, ab) / abLengthSquared, 0.0, 1.0);
+    return p - (a + t * ab);
+}
+
+ivec2 vectorIndexToUv(int index, ivec2 size)
+{
+    int v = index / size.x;
+    int u = index - v * size.x;
+    return ivec2(u, v);
+}
+
+// Drape clamped vector polylines onto the terrain surface. The fragment's
+// tile UV picks a grid cell, then only that cell's line segments (packed in
+// tile-local UV space) are tested for proximity. Within the line width, the
+// vector color is alpha-composited over the terrain (no discard).
+vec4 vectorPolylineRender(vec2 vectorUv, vec4 baseColor)
+{
+    // A tile without polylines binds a 1x1 placeholder; a real grid header
+    // [gridWidth, gridHeight, ...] is at least 3 texels.
+    ivec2 headerSize = textureSize(u_vectorGridCellIndicesTexture, 0);
+    if (headerSize.x * headerSize.y < 3)
+    {
+        return baseColor;
+    }
+
+    // Inverse UV-per-pixel Jacobian: measures line distance in screen pixels so
+    // width stays constant under anisotropic (oblique) foreshortening.
+    mat2 screenFromUv = inverse(mat2(dFdx(vectorUv), dFdy(vectorUv)));
+    int gridWidth = int(texelFetch(u_vectorGridCellIndicesTexture, vectorIndexToUv(0, headerSize), 0).r);
+    int gridHeight = int(texelFetch(u_vectorGridCellIndicesTexture, vectorIndexToUv(1, headerSize), 0).r);
+    int cellX = clamp(int(vectorUv.x * float(gridWidth)), 0, gridWidth - 1);
+    int cellY = clamp(int(vectorUv.y * float(gridHeight)), 0, gridHeight - 1);
+    int cellIndex = cellX + cellY * gridWidth;
+
+    // Cell end offsets follow the two gridWidth/gridHeight texels, so cell
+    // N's end is at texel N + 2. A cell's start is the previous cell's end
+    // (texel N + 1); cell 0's start is implicitly 0.
+    int indexEnd = int(texelFetch(u_vectorGridCellIndicesTexture, vectorIndexToUv(cellIndex + 2, headerSize), 0).r);
+    int indexStart = cellIndex == 0
+        ? 0
+        : int(texelFetch(u_vectorGridCellIndicesTexture, vectorIndexToUv(cellIndex + 1, headerSize), 0).r);
+
+    ivec2 segmentTextureSize = textureSize(u_vectorSegmentTexture, 0);
+    ivec2 primitiveTextureSize = textureSize(u_vectorWidthTexture, 0);
+
+    for (int i = indexStart; i < indexEnd; i++)
+    {
+        ivec2 segmentUv = vectorIndexToUv(i, segmentTextureSize);
+        vec4 segment = texelFetch(u_vectorSegmentTexture, segmentUv, 0);
+
+        int primitiveIndex = int(texelFetch(u_vectorSegmentPrimitiveIndicesTexture, segmentUv, 0).r);
+        ivec2 primitiveUv = vectorIndexToUv(primitiveIndex, primitiveTextureSize);
+
+        float lineWidth = texelFetch(u_vectorWidthTexture, primitiveUv, 0).r * 255.0;
+
+        vec2 offsetUv = vectorOffsetToLine(vectorUv, segment);
+        if (length(screenFromUv * offsetUv) < lineWidth)
+        {
+            // Alpha-composite vector over terrain.
+            vec4 vectorColor = texelFetch(u_vectorColorTexture, primitiveUv, 0);
+            baseColor = vectorColor * vec4(vectorColor.aaa, 1.0) + baseColor * (1.0 - vectorColor.a);
+            break;
+        }
+    }
+
+    return baseColor;
+}
+
+// Composites a polygon's fill over baseColor when the pixel is inside it. A
+// negative index (empty cell or first iteration) or an outside pixel is a
+// no-op.
+vec4 vectorCompositePolygonFill(vec4 baseColor, int primitiveIndex, bool inside, ivec2 primitiveTextureSize)
+{
+    if (!inside || primitiveIndex < 0)
+    {
+        return baseColor;
+    }
+
+    ivec2 primitiveUv = vectorIndexToUv(primitiveIndex, primitiveTextureSize);
+    vec4 fillColor = texelFetch(u_vectorColorTexture, primitiveUv, 0);
+    return fillColor * vec4(fillColor.aaa, 1.0) + baseColor * (1.0 - fillColor.a);
+}
+
+// True if a horizontal +x ray from p crosses the edge. The half-open interval
+// (> vs <=) counts a ray through a shared vertex exactly once.
+bool vectorEdgeCrossesRay(vec4 edge, vec2 p)
+{
+    if ((edge.y > p.y) == (edge.w > p.y))
+    {
+        return false;
+    }
+
+    float t = (p.y - edge.y) / (edge.w - edge.y);
+    float xIntersect = edge.x + t * (edge.z - edge.x);
+    return p.x < xIntersect;
+}
+
+// Drape clamped vector polygon fills onto the terrain surface. The fragment's
+// tile UV picks a grid cell whose edges were clipped to the cell on the CPU,
+// forming closed loops, so an even-odd horizontal ray cast within the cell
+// decides coverage. Edges arrive grouped by primitive; each covering
+// primitive's fill color is alpha-composited in primitive order (no discard).
+vec4 vectorPolygonRender(vec2 vectorUv, vec4 baseColor)
+{
+    // A tile without polygons binds a 1x1 placeholder; a real grid header
+    // [gridWidth, gridHeight, ...] is at least 3 texels.
+    ivec2 headerSize = textureSize(u_vectorPolygonGridCellIndicesTexture, 0);
+    if (headerSize.x * headerSize.y < 3)
+    {
+        return baseColor;
+    }
+
+    int gridWidth = int(texelFetch(u_vectorPolygonGridCellIndicesTexture, vectorIndexToUv(0, headerSize), 0).r);
+    int gridHeight = int(texelFetch(u_vectorPolygonGridCellIndicesTexture, vectorIndexToUv(1, headerSize), 0).r);
+    int cellX = clamp(int(vectorUv.x * float(gridWidth)), 0, gridWidth - 1);
+    int cellY = clamp(int(vectorUv.y * float(gridHeight)), 0, gridHeight - 1);
+    int cellIndex = cellX + cellY * gridWidth;
+
+    // Cell end offsets follow the two gridWidth/gridHeight texels, so cell
+    // N's end is at texel N + 2. A cell's start is the previous cell's end
+    // (texel N + 1); cell 0's start is implicitly 0.
+    int indexEnd = int(texelFetch(u_vectorPolygonGridCellIndicesTexture, vectorIndexToUv(cellIndex + 2, headerSize), 0).r);
+    int indexStart = cellIndex == 0
+        ? 0
+        : int(texelFetch(u_vectorPolygonGridCellIndicesTexture, vectorIndexToUv(cellIndex + 1, headerSize), 0).r);
+
+    ivec2 edgeTextureSize = textureSize(u_vectorPolygonEdgeTexture, 0);
+    ivec2 primitiveTextureSize = textureSize(u_vectorColorTexture, 0);
+
+    int currentPrimitive = -1;
+    bool inside = false;
+
+    for (int i = indexStart; i < indexEnd; i++)
+    {
+        ivec2 edgeUv = vectorIndexToUv(i, edgeTextureSize);
+        vec4 edge = texelFetch(u_vectorPolygonEdgeTexture, edgeUv, 0);
+        int primitiveIndex = int(texelFetch(u_vectorPolygonEdgePrimitiveIndicesTexture, edgeUv, 0).r);
+
+        // A new primitive means the previous group is complete: composite it,
+        // then start counting the new one fresh.
+        if (primitiveIndex != currentPrimitive)
+        {
+            baseColor = vectorCompositePolygonFill(baseColor, currentPrimitive, inside, primitiveTextureSize);
+            currentPrimitive = primitiveIndex;
+            inside = false;
+        }
+
+        if (vectorEdgeCrossesRay(edge, vectorUv))
+        {
+            inside = !inside;
+        }
+    }
+
+    // The last primitive group has no trailing edge to trigger its composite.
+    baseColor = vectorCompositePolygonFill(baseColor, currentPrimitive, inside, primitiveTextureSize);
+
+    return baseColor;
+}