@cesium/engine 26.2.0 → 26.3.1-wasm.0

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

@@ -177,6 +177,10 @@ void main()
     modelClippingPolygonsStage();
     #endif
 
+    #ifdef HAS_VECTOR_LOOKUP
+    modelVectorLookupStage(color);
+    #endif
+
     //========================================================================
     // When not picking metadata START
     #ifndef METADATA_PICKING_ENABLED

package/Source/Shaders/Model/ModelFS.js

@@ -177,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\

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

@@ -1,11 +1,29 @@
+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_vectorColorTexture;
 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)
@@ -29,12 +47,59 @@ ivec2 vectorIndexToUv(int index, ivec2 size)
     return ivec2(u, v);
 }
 
-// Drape clamped vector polylines onto the terrain surface. The fragment's
+// 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);
@@ -43,27 +108,17 @@ vec4 vectorPolylineRender(vec2 vectorUv, vec4 baseColor)
         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 range = vectorCellRange(vectorUv, u_vectorGridCellIndicesTexture);
     ivec2 segmentTextureSize = textureSize(u_vectorSegmentTexture, 0);
     ivec2 primitiveTextureSize = textureSize(u_vectorWidthTexture, 0);
 
-    for (int i = indexStart; i < indexEnd; i++)
+    // 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);
@@ -71,19 +126,56 @@ vec4 vectorPolylineRender(vec2 vectorUv, vec4 baseColor)
         int primitiveIndex = int(texelFetch(u_vectorSegmentPrimitiveIndicesTexture, segmentUv, 0).r);
         ivec2 primitiveUv = vectorIndexToUv(primitiveIndex, primitiveTextureSize);
 
-        float lineWidth = texelFetch(u_vectorWidthTexture, primitiveUv, 0).r * 255.0;
+        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;
+        }
 
-        vec2 offsetUv = vectorOffsetToLine(vectorUv, segment);
-        if (length(screenFromUv * offsetUv) < lineWidth)
+        // 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)
         {
-            // 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;
         }
     }
 
+    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
@@ -96,6 +188,8 @@ vec4 vectorCompositePolygonFill(vec4 baseColor, int primitiveIndex, bool inside,
         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);
@@ -115,42 +209,22 @@ bool vectorEdgeCrossesRay(vec4 edge, vec2 p)
     return p.x < xIntersect;
 }
 
-// Drape clamped vector polygon fills onto the terrain surface. The fragment's
+// 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)
 {
-    // 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);
-
+#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 = indexStart; i < indexEnd; i++)
+    for (int i = range.x; i < range.y; i++)
     {
         ivec2 edgeUv = vectorIndexToUv(i, edgeTextureSize);
         vec4 edge = texelFetch(u_vectorPolygonEdgeTexture, edgeUv, 0);
@@ -175,4 +249,57 @@ vec4 vectorPolygonRender(vec2 vectorUv, vec4 baseColor)
     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
 }