@cesium/engine 26.2.0 → 26.3.0

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
 }