@cesium/engine 26.1.0 → 26.3.0

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\
@@ -130,6 +177,10 @@ void main()\n\
     #ifdef ENABLE_CLIPPING_POLYGONS\n\
     modelClippingPolygonsStage();\n\
     #endif\n\
+\n\
+    #ifdef HAS_VECTOR_LOOKUP\n\
+    modelVectorLookupStage(color);\n\
+    #endif\n\
 \n\
     //========================================================================\n\
     // When not picking metadata START\n\
@@ -146,6 +197,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 +210,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/Model/ModelVS.glsl

@@ -110,6 +110,11 @@ void main()
     // This returns the value that will be assigned to gl_Position.
     vec4 positionClip = geometryStage(attributes, modelView, normal);
 
+    // Must go after the geometry stage, which computes v_positionEC.
+    #ifdef ENABLE_CLIPPING_POLYGONS
+    modelClippingPolygonsStage();
+    #endif
+
     #if defined(HAS_LINE_CUMULATIVE_DISTANCE) || defined(HAS_LINE_PATTERN)
     lineStyleStageVS(attributes);
     #endif
@@ -119,8 +124,8 @@ void main()
     atmosphereStage(attributes);
     #endif
 
-    #ifdef ENABLE_CLIPPING_POLYGONS
-    modelClippingPolygonsStage(attributes);
+    #ifdef HAS_VECTOR_LOOKUP
+    modelVectorLookupStage(attributes);
     #endif
 
     #ifdef HAS_SILHOUETTE

package/Source/Shaders/Model/ModelVS.js

@@ -110,6 +110,11 @@ void main()\n\
     // Compute the final position in each coordinate system needed.\n\
     // This returns the value that will be assigned to gl_Position.\n\
     vec4 positionClip = geometryStage(attributes, modelView, normal);\n\
+\n\
+    // Must go after the geometry stage, which computes v_positionEC.\n\
+    #ifdef ENABLE_CLIPPING_POLYGONS\n\
+    modelClippingPolygonsStage();\n\
+    #endif\n\
 \n\
     #if defined(HAS_LINE_CUMULATIVE_DISTANCE) || defined(HAS_LINE_PATTERN)\n\
     lineStyleStageVS(attributes);\n\
@@ -120,8 +125,8 @@ void main()\n\
     atmosphereStage(attributes);\n\
     #endif\n\
 \n\
-    #ifdef ENABLE_CLIPPING_POLYGONS\n\
-    modelClippingPolygonsStage(attributes);\n\
+    #ifdef HAS_VECTOR_LOOKUP\n\
+    modelVectorLookupStage(attributes);\n\
     #endif\n\
 \n\
     #ifdef HAS_SILHOUETTE\n\

package/Source/Shaders/Model/ModelVectorLookupStageFS.glsl

@@ -0,0 +1,6 @@
+void modelVectorLookupStage(inout vec4 color)
+{
+    // Fills composite before strokes. Both no-op against 1x1 placeholder textures.
+    color = vectorPolygonRender(v_vectorUv, color);
+    color = vectorPolylineRender(v_vectorUv, color);
+}

package/Source/Shaders/Model/ModelVectorLookupStageFS.js

@@ -0,0 +1,8 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "void modelVectorLookupStage(inout vec4 color)\n\
+{\n\
+    // Fills composite before strokes. Both no-op against 1x1 placeholder textures.\n\
+    color = vectorPolygonRender(v_vectorUv, color);\n\
+    color = vectorPolylineRender(v_vectorUv, color);\n\
+}\n\
+";

package/Source/Shaders/Model/ModelVectorLookupStageVS.glsl

@@ -0,0 +1,15 @@
+/**
+ * Derives each vertex's UV within the rectangle the lookup textures were baked for, where [0,1] spans the rectangle.
+ * {@link ModelVectorLookupStageFS.glsl} samples those textures with it.
+ *
+ * v_positionWC is unusable here: it is 32-bit and too large to resolve a geodetic position precisely, and splitting it
+ * into hi/lo components would still not support the trigonometry needed to derive longitude and latitude. Instead,
+ * {@link czm_eyeToCartographicDelta} returns a geodetic delta from the camera to the vertex, a small quantity that
+ * grows more precise as the camera approaches. Adding it to the camera's own UV, computed on the CPU in double
+ * precision, keeps the result precise across the rectangle.
+ */
+void modelVectorLookupStage(ProcessedAttributes attributes)
+{
+    vec2 delta = czm_eyeToCartographicDelta(v_positionEC).xy;
+    v_vectorUv = u_vectorCameraUv + delta * u_vectorRectangleInverseSize;
+}

package/Source/Shaders/Model/ModelVectorLookupStageVS.js

@@ -0,0 +1,17 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "/**\n\
+ * Derives each vertex's UV within the rectangle the lookup textures were baked for, where [0,1] spans the rectangle.\n\
+ * {@link ModelVectorLookupStageFS.glsl} samples those textures with it.\n\
+ *\n\
+ * v_positionWC is unusable here: it is 32-bit and too large to resolve a geodetic position precisely, and splitting it\n\
+ * into hi/lo components would still not support the trigonometry needed to derive longitude and latitude. Instead,\n\
+ * {@link czm_eyeToCartographicDelta} returns a geodetic delta from the camera to the vertex, a small quantity that\n\
+ * grows more precise as the camera approaches. Adding it to the camera's own UV, computed on the CPU in double\n\
+ * precision, keeps the result precise across the rectangle.\n\
+ */\n\
+void modelVectorLookupStage(ProcessedAttributes attributes)\n\
+{\n\
+    vec2 delta = czm_eyeToCartographicDelta(v_positionEC).xy;\n\
+    v_vectorUv = u_vectorCameraUv + delta * u_vectorRectangleInverseSize;\n\
+}\n\
+";

package/Source/Shaders/Model/VerticalExaggerationStageVS.glsl

@@ -12,28 +12,27 @@ void verticalExaggerationStage(
   // Uses a circular approximation for the Earth curvature along the geodesic.
   vec3 vertexPositionEC = (czm_modelView * vec4(attributes.positionMC, 1.0)).xyz;
   vec3 centerToVertex = eyeToCenter * czm_eyeEllipsoidNormalEC + vertexPositionEC;
-  vec3 vertexNormal = normalize(centerToVertex);
+  vec3 vertexEllipsoidNormalEC = normalize(centerToVertex);
 
-  // Estimate the (sine of the) angle between the camera direction and the vertex normal
+  // Estimate the (sine of the) angle between the camera direction and the ellipsoid normal.
   float verticalDistance = dot(vertexPositionEC, czm_eyeEllipsoidNormalEC);
   float horizontalDistance = length(vertexPositionEC - verticalDistance * czm_eyeEllipsoidNormalEC);
   float sinTheta = horizontalDistance / (eyeToCenter + verticalDistance);
   bool isSmallAngle = clamp(sinTheta, 0.0, 0.05) == sinTheta;
 
   // Approximate the change in height above the ellipsoid, from camera to vertex position.
-  float exactVersine = 1.0 - dot(czm_eyeEllipsoidNormalEC, vertexNormal);
+  float exactVersine = 1.0 - dot(czm_eyeEllipsoidNormalEC, vertexEllipsoidNormalEC);
   float smallAngleVersine = 0.5 * sinTheta * sinTheta;
   float versine = isSmallAngle ? smallAngleVersine : exactVersine;
-  float dHeight = dot(vertexPositionEC, vertexNormal) - eyeToCenter * versine;
+  float dHeight = dot(vertexPositionEC, vertexEllipsoidNormalEC) - eyeToCenter * versine;
   float vertexHeight = czm_eyeHeight + dHeight;
 
-  // Transform the approximate vertex normal to model coordinates.
-  vec3 vertexNormalMC = (czm_inverseModelView * vec4(vertexNormal, 0.0)).xyz;
-  vertexNormalMC = normalize(vertexNormalMC);
+  // Transform the approximate ellipsoid normal to model coordinates.
+  vec3 exaggerationDirectionScaledMC = (czm_inverseModelView * vec4(vertexEllipsoidNormalEC, 0.0)).xyz;
 
-  // Compute the exaggeration and apply it along the approximate vertex normal.
+  // Compute the exaggeration and apply it along the exaggeration direction in model coordinates.
   float stretch = u_verticalExaggerationAndRelativeHeight.x;
   float shift = u_verticalExaggerationAndRelativeHeight.y;
   float exaggeration = (vertexHeight - shift) * (stretch - 1.0);
-  attributes.positionMC += exaggeration * vertexNormalMC;
-}
+  attributes.positionMC += exaggeration * exaggerationDirectionScaledMC;
+}

package/Source/Shaders/Model/VerticalExaggerationStageVS.js

@@ -13,29 +13,27 @@ export default "void verticalExaggerationStage(\n\
   // Uses a circular approximation for the Earth curvature along the geodesic.\n\
   vec3 vertexPositionEC = (czm_modelView * vec4(attributes.positionMC, 1.0)).xyz;\n\
   vec3 centerToVertex = eyeToCenter * czm_eyeEllipsoidNormalEC + vertexPositionEC;\n\
-  vec3 vertexNormal = normalize(centerToVertex);\n\
+  vec3 vertexEllipsoidNormalEC = normalize(centerToVertex);\n\
 \n\
-  // Estimate the (sine of the) angle between the camera direction and the vertex normal\n\
+  // Estimate the (sine of the) angle between the camera direction and the ellipsoid normal.\n\
   float verticalDistance = dot(vertexPositionEC, czm_eyeEllipsoidNormalEC);\n\
   float horizontalDistance = length(vertexPositionEC - verticalDistance * czm_eyeEllipsoidNormalEC);\n\
   float sinTheta = horizontalDistance / (eyeToCenter + verticalDistance);\n\
   bool isSmallAngle = clamp(sinTheta, 0.0, 0.05) == sinTheta;\n\
 \n\
   // Approximate the change in height above the ellipsoid, from camera to vertex position.\n\
-  float exactVersine = 1.0 - dot(czm_eyeEllipsoidNormalEC, vertexNormal);\n\
+  float exactVersine = 1.0 - dot(czm_eyeEllipsoidNormalEC, vertexEllipsoidNormalEC);\n\
   float smallAngleVersine = 0.5 * sinTheta * sinTheta;\n\
   float versine = isSmallAngle ? smallAngleVersine : exactVersine;\n\
-  float dHeight = dot(vertexPositionEC, vertexNormal) - eyeToCenter * versine;\n\
+  float dHeight = dot(vertexPositionEC, vertexEllipsoidNormalEC) - eyeToCenter * versine;\n\
   float vertexHeight = czm_eyeHeight + dHeight;\n\
 \n\
-  // Transform the approximate vertex normal to model coordinates.\n\
-  vec3 vertexNormalMC = (czm_inverseModelView * vec4(vertexNormal, 0.0)).xyz;\n\
-  vertexNormalMC = normalize(vertexNormalMC);\n\
+  // Transform the approximate ellipsoid normal to model coordinates.\n\
+  vec3 exaggerationDirectionScaledMC = (czm_inverseModelView * vec4(vertexEllipsoidNormalEC, 0.0)).xyz;\n\
 \n\
-  // Compute the exaggeration and apply it along the approximate vertex normal.\n\
+  // Compute the exaggeration and apply it along the exaggeration direction in model coordinates.\n\
   float stretch = u_verticalExaggerationAndRelativeHeight.x;\n\
   float shift = u_verticalExaggerationAndRelativeHeight.y;\n\
   float exaggeration = (vertexHeight - shift) * (stretch - 1.0);\n\
-  attributes.positionMC += exaggeration * vertexNormalMC;\n\
-}\n\
-";
+  attributes.positionMC += exaggeration * exaggerationDirectionScaledMC;\n\
+}";

package/Source/Shaders/VectorCommon.glsl

@@ -0,0 +1,305 @@
+uniform highp sampler2D u_vectorColorTexture;
+uniform highp sampler2D u_vectorPickColorTexture;
+
+// Primitive index of the topmost vector draped over this fragment, or -1 for none.
+int vectorPickPrimitiveIndex = -1;
+
+#ifdef HAS_VECTOR_POLYLINES
+uniform highp sampler2D u_vectorSegmentTexture;
+uniform highp sampler2D u_vectorWidthTexture;
+uniform highp sampler2D u_vectorSegmentPrimitiveIndicesTexture;
+uniform highp sampler2D u_vectorGridCellIndicesTexture;
+#ifdef VECTOR_WIDTH_IN_METERS
+// Ground size, in meters, of the tile's UV domain.
+uniform vec2 u_vectorMetersPerUv;
+#endif
+#endif
+
+#ifdef HAS_VECTOR_POLYGONS
+uniform highp sampler2D u_vectorPolygonEdgeTexture;
+uniform highp sampler2D u_vectorPolygonEdgePrimitiveIndicesTexture;
+uniform highp sampler2D u_vectorPolygonGridCellIndicesTexture;
+#endif
+
+uniform highp sampler2D u_clippingEdgeTexture;
+uniform highp sampler2D u_clippingEdgePrimitiveIndicesTexture;
+uniform highp sampler2D u_clippingGridCellIndicesTexture;
+
+// 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);
+}
+
+// Returns [start, end) index range for the grid cell containing uv. An empty
+// range (start == end == 0) means a placeholder grid, so callers loop zero times.
+ivec2 vectorCellRange(vec2 uv, highp sampler2D gridCellIndicesTexture)
+{
+    ivec2 headerSize = textureSize(gridCellIndicesTexture, 0);
+    if (headerSize.x * headerSize.y < 3)
+    {
+        return ivec2(0);
+    }
+
+    int gridWidth  = int(texelFetch(gridCellIndicesTexture, vectorIndexToUv(0, headerSize), 0).r);
+    int gridHeight = int(texelFetch(gridCellIndicesTexture, vectorIndexToUv(1, headerSize), 0).r);
+    int cellX = clamp(int(uv.x * float(gridWidth)),  0, gridWidth  - 1);
+    int cellY = clamp(int(uv.y * float(gridHeight)), 0, gridHeight - 1);
+    int cellIndex = cellX + cellY * gridWidth;
+
+    int indexEnd = int(texelFetch(gridCellIndicesTexture, vectorIndexToUv(cellIndex + 2, headerSize), 0).r);
+    int indexStart = cellIndex == 0
+        ? 0
+        : int(texelFetch(gridCellIndicesTexture, vectorIndexToUv(cellIndex + 1, headerSize), 0).r);
+
+    return ivec2(indexStart, indexEnd);
+}
+
+#ifdef VECTOR_ANTIALIAS
+// Half-pixel band across a line's edge over which coverage fades.
+const float vectorCoverageRadius = 0.5;
+#else
+const float vectorCoverageRadius = 0.0;
+#endif
+
+// Drape 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)
+{
+#ifdef HAS_VECTOR_POLYLINES
+    // Inverse UV-per-pixel Jacobian: measures line distance in screen pixels so
+    // width stays constant under anisotropic (oblique) foreshortening.
+    // Computed unconditionally so the derivatives stay in uniform control flow.
+    mat2 screenFromUv = inverse(mat2(dFdx(vectorUv), dFdy(vectorUv)));
+
+#ifdef VECTOR_WIDTH_IN_METERS
+    mat2 metersFromUv = mat2(u_vectorMetersPerUv.x, 0.0, 0.0, u_vectorMetersPerUv.y);
+    // Edge distances are always compared in pixels, whatever unit a width was authored in,
+    // so ground meters are converted using the coarser of the two screen axes.
+    // Computed unconditionally so the derivatives stay in uniform control flow.
+    float pixelsPerMeter = 1.0 / max(
+        length(metersFromUv * dFdx(vectorUv)),
+        length(metersFromUv * dFdy(vectorUv)));
+#endif
+
+    // 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;
+    }
+
+    ivec2 range = vectorCellRange(vectorUv, u_vectorGridCellIndicesTexture);
+    ivec2 segmentTextureSize = textureSize(u_vectorSegmentTexture, 0);
+    ivec2 primitiveTextureSize = textureSize(u_vectorWidthTexture, 0);
+
+    // Signed distance to the nearest edge, negative inside the line. Consecutive
+    // segments overlap at their shared vertex, so only the nearest is composited;
+    // compositing each in turn would darken the joints.
+    float nearestEdgeDistance = 1.0e30;
+    int nearestPrimitiveIndex = -1;
+
+    for (int i = range.x; i < range.y; 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 width = texelFetch(u_vectorWidthTexture, primitiveUv, 0).r;
+        float halfWidth = abs(width) * 0.5;
+        vec2 offsetToLine = vectorOffsetToLine(vectorUv, segment);
+
+#if defined(VECTOR_WIDTH_MIXED_UNITS)
+        // A negative width marks a width in meters; see VectorPipeline.
+        float edgeDistance = width < 0.0
+            ? (length(metersFromUv * offsetToLine) - halfWidth) * pixelsPerMeter
+            : length(screenFromUv * offsetToLine) - halfWidth;
+#elif defined(VECTOR_WIDTH_IN_METERS)
+        float edgeDistance = (length(metersFromUv * offsetToLine) - halfWidth) * pixelsPerMeter;
+#else
+        float edgeDistance = length(screenFromUv * offsetToLine) - halfWidth;
+#endif
+
+        if (edgeDistance < nearestEdgeDistance)
+        {
+            nearestEdgeDistance = edgeDistance;
+            nearestPrimitiveIndex = primitiveIndex;
+        }
+
+        // Coverage is saturated; no further segment can raise it. Only the nearest
+        // segment supplies the color, so overlapping translucent lines do not blend.
+        if (nearestEdgeDistance <= -vectorCoverageRadius)
+        {
+            break;
+        }
+    }
+
+    if (nearestEdgeDistance > vectorCoverageRadius)
+    {
+        return baseColor;
+    }
+
+#ifdef VECTOR_ANTIALIAS
+    float coverage = 1.0 - smoothstep(-vectorCoverageRadius, vectorCoverageRadius, nearestEdgeDistance);
+#else
+    float coverage = 1.0;
+#endif
+
+    vectorPickPrimitiveIndex = nearestPrimitiveIndex;
+
+    // Alpha-composite vector over terrain.
+    ivec2 primitiveUv = vectorIndexToUv(nearestPrimitiveIndex, primitiveTextureSize);
+    vec4 vectorColor = texelFetch(u_vectorColorTexture, primitiveUv, 0);
+    vectorColor.a *= coverage;
+    return vectorColor * vec4(vectorColor.aaa, 1.0) + baseColor * (1.0 - vectorColor.a);
+#else
+    return baseColor;
+#endif
+}
+
+// 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;
+    }
+
+    vectorPickPrimitiveIndex = primitiveIndex;
+
+    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 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)
+{
+#ifdef HAS_VECTOR_POLYGONS
+    ivec2 range = vectorCellRange(vectorUv, u_vectorPolygonGridCellIndicesTexture);
+    ivec2 edgeTextureSize = textureSize(u_vectorPolygonEdgeTexture, 0);
+    ivec2 primitiveTextureSize = textureSize(u_vectorColorTexture, 0);
+
+    int currentPrimitive = -1;
+    bool inside = false;
+
+    for (int i = range.x; i < range.y; 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;
+#else
+    return baseColor;
+#endif
+}
+
+// Pick color of the vector draped over this fragment, or the surface's own where none is.
+vec4 vectorPickColorOver(vec4 surfacePickColor)
+{
+    if (vectorPickPrimitiveIndex < 0)
+    {
+        return surfacePickColor;
+    }
+
+    ivec2 primitiveTextureSize = textureSize(u_vectorPickColorTexture, 0);
+    return texelFetch(u_vectorPickColorTexture, vectorIndexToUv(vectorPickPrimitiveIndex, primitiveTextureSize), 0);
+}
+
+// Returns true if uv is inside any polygon in its grid cell
+// If performing inverse-clipping, it is up to the caller to negate the result.
+bool vectorClip(vec2 uv)
+{
+    // Clamp to [0, 1] to address small interpolation precision error that can occur at the boundaries of tiles
+    uv = clamp(uv, vec2(0.0), vec2(1.0));
+    ivec2 range = vectorCellRange(uv, u_clippingGridCellIndicesTexture);
+    ivec2 edgeTextureSize = textureSize(u_clippingEdgeTexture, 0);
+
+    int currentPrimitive = -1;
+    bool inside = false;
+
+    for (int i = range.x; i < range.y; i++)
+    {
+        ivec2 edgeUv = vectorIndexToUv(i, edgeTextureSize);
+        int primitiveIndex = int(texelFetch(u_clippingEdgePrimitiveIndicesTexture, edgeUv, 0).r);
+
+        // New primitive: the previous group is complete, check if it was inside and return early if so.
+        if (primitiveIndex != currentPrimitive)
+        {
+            if (inside)
+            {
+                return true;
+            }
+            currentPrimitive = primitiveIndex;
+            inside = false;
+        }
+
+        vec4 edge = texelFetch(u_clippingEdgeTexture, edgeUv, 0);
+        if (vectorEdgeCrossesRay(edge, uv))
+        {
+            inside = !inside;
+        }
+    }
+
+    return inside; // last group
+}