@cesium/engine 26.2.0 → 26.3.1-wasm.0

package/Source/Scene/WebMapServiceImageryProvider.js

@@ -48,7 +48,10 @@ const excludesReverseAxis = [
  * @property {object} [getFeatureInfoParameters=WebMapServiceImageryProvider.GetFeatureInfoDefaultParameters] Additional parameters to pass to the WMS server in the GetFeatureInfo URL.
  * @property {Resource|string} [getFeatureInfoUrl] The getFeatureInfo URL of the WMS service. If the property is not defined then we use the property value of url.
  * @property {GetFeatureInfoFormat[]} [getFeatureInfoFormats=WebMapServiceImageryProvider.DefaultGetFeatureInfoFormats] The formats
- *        in which to try WMS GetFeatureInfo requests.
+ *        in which to try WMS GetFeatureInfo requests. Since feature info responses vary across WMS services,
+ *        you may need to supply a custom format and parsing callback; see the
+ *        {@link https://sandcastle.cesium.com/?id=web-map-tile-service-picking|Sandcastle example} for a complete
+ *        example of writing your own callback.
  * @property {Rectangle} [rectangle=Rectangle.MAX_VALUE] The rectangle of the layer.
  * @property {TilingScheme} [tilingScheme=new GeographicTilingScheme()] The tiling scheme to use to divide the world into tiles.
  * @property {Ellipsoid} [ellipsoid] The ellipsoid.  If the tilingScheme is specified,
@@ -90,6 +93,7 @@ const excludesReverseAxis = [
  *
  * @see {@link https://enterprise.arcgis.com/en/server/latest/publish-services/linux/wms-services.htm|ArcGIS Server WMS Services}
  * @see {@link http://www.w3.org/TR/cors/|Cross-Origin Resource Sharing}
+ * @see {@link https://sandcastle.cesium.com/?id=web-map-tile-service-picking|Custom GetFeatureInfo Sandcastle Example}
  *
  * @example
  * // WMS servers operated by the US government https://apps.nationalmap.gov/services/

package/Source/Scene/WebMapTileServiceImageryProvider.js

@@ -29,7 +29,10 @@ import GetFeatureInfoFormat from "./GetFeatureInfoFormat.js";
  * @property {object} [getFeatureInfoParameters] Additional parameters to include in GetFeatureInfo requests. Keys are lowercased internally.
  * @property {Resource|string} [getFeatureInfoUrl] The GetFeatureInfo URL of the WMTS service. If not specified, the value of <code>url</code> is used.
  * @property {GetFeatureInfoFormat[]} [getFeatureInfoFormats=WebMapTileServiceImageryProvider.DefaultGetFeatureInfoFormats] The formats
- *                          in which to try WMTS GetFeatureInfo requests.
+ *                          in which to try WMTS GetFeatureInfo requests. Since feature info responses vary across WMTS services,
+ *                          you may need to supply a custom format and parsing callback; see the
+ *                          {@link https://sandcastle.cesium.com/?id=web-map-tile-service-picking|Sandcastle example} for a complete
+ *                          example of writing your own callback.
  * @property {Rectangle} [rectangle=Rectangle.MAX_VALUE] The rectangle covered by the layer.
  * @property {TilingScheme} [tilingScheme] The tiling scheme corresponding to the organization of the tiles in the TileMatrixSet.
  * @property {Ellipsoid} [ellipsoid] The ellipsoid.  If not specified, the WGS84 ellipsoid is used.
@@ -176,6 +179,8 @@ import GetFeatureInfoFormat from "./GetFeatureInfoFormat.js";
  * @see TileMapServiceImageryProvider
  * @see WebMapServiceImageryProvider
  * @see UrlTemplateImageryProvider
+ * 
+ * @see {@link https://sandcastle.cesium.com/?id=web-map-tile-service-picking|Custom GetFeatureInfo Sandcastle Example}
  */
 function WebMapTileServiceImageryProvider(options) {
   options = options ?? Frozen.EMPTY_OBJECT;

package/Source/Scene/renderBufferPolylineCollection.js

@@ -168,6 +168,8 @@ function renderBufferPolylineCollection(collection, frameState, renderContext) {
   if (collection._dirtyCount > 0) {
     const { _dirtyOffset, _dirtyCount } = collection;
 
+    const widthInMeters = collection.widthUnits === "meters";
+
     const indexArray = renderContext.indexArray;
 
     const {
@@ -200,6 +202,8 @@ function renderBufferPolylineCollection(collection, frameState, renderContext) {
       polyline.getMaterial(material);
       const encodedColor = AttributeCompression.encodeRGB8(material.color);
       const colorAlpha = material.color.alpha;
+      // A negative width marks a width in meters, which the shader converts to pixels.
+      const signedWidth = widthInMeters ? -material.width : material.width;
       Color.fromRgba(polyline._pickId, pickColor);
       const show = polyline.show;
 
@@ -306,7 +310,7 @@ function renderBufferPolylineCollection(collection, frameState, renderContext) {
 
           showColorWidthAndTexCoordArray[vOffset * 4] = show ? 1 : 0;
           showColorWidthAndTexCoordArray[vOffset * 4 + 1] = encodedColor;
-          showColorWidthAndTexCoordArray[vOffset * 4 + 2] = material.width;
+          showColorWidthAndTexCoordArray[vOffset * 4 + 2] = signedWidth;
           showColorWidthAndTexCoordArray[vOffset * 4 + 3] = j / (jl - 1);
 
           alphaArray[vOffset] = colorAlpha * 255.0;

package/Source/Shaders/BufferPolylineMaterialVS.glsl

@@ -24,7 +24,7 @@ void main()
 {
     float show = showColorWidthAndTexCoord.x;
     vec4 color = czm_decodeRGB8(showColorWidthAndTexCoord.y);
-    float width = showColorWidthAndTexCoord.z;
+    float signedWidth = showColorWidthAndTexCoord.z;
     float texCoord = showColorWidthAndTexCoord.w;
 
     ///////////////////////////////////////////////////////////////////////////
@@ -37,11 +37,23 @@ void main()
     vec4 positionEC = czm_translateRelativeToEye(positionHigh, positionLow);
     vec4 prevPositionEC = czm_translateRelativeToEye(prevPositionHigh, prevPositionLow);
     vec4 nextPositionEC = czm_translateRelativeToEye(nextPositionHigh, nextPositionLow);
-    vec4 positionWC = getPolylineWindowCoordinates(positionEC, prevPositionEC, nextPositionEC, expandDir, width, usePrevious, polylineAngle);
 #else
     vec4 positionEC = czm_modelView * vec4(position, 1.0);
     vec4 prevPositionEC = czm_modelView * vec4(prevPosition, 1.0);
     vec4 nextPositionEC = czm_modelView * vec4(nextPosition, 1.0);
+#endif
+
+    // A negative width is in meters; see renderBufferPolylineCollection. The quad is
+    // extruded in window coordinates, so convert it at this vertex's depth.
+    float width = abs(signedWidth);
+    if (signedWidth < 0.0)
+    {
+        width /= max(czm_metersPerPixel(positionEC), czm_epsilon7);
+    }
+
+#ifdef USE_FLOAT64
+    vec4 positionWC = getPolylineWindowCoordinates(positionEC, prevPositionEC, nextPositionEC, expandDir, width, usePrevious, polylineAngle);
+#else
     // Positions are already in eye space; use the EC variant to skip the redundant transform.
     vec4 positionWC = getPolylineWindowCoordinatesEC(positionEC, prevPositionEC, nextPositionEC, expandDir, width, usePrevious, polylineAngle);
 #endif

package/Source/Shaders/BufferPolylineMaterialVS.js

@@ -25,7 +25,7 @@ void main()\n\
 {\n\
     float show = showColorWidthAndTexCoord.x;\n\
     vec4 color = czm_decodeRGB8(showColorWidthAndTexCoord.y);\n\
-    float width = showColorWidthAndTexCoord.z;\n\
+    float signedWidth = showColorWidthAndTexCoord.z;\n\
     float texCoord = showColorWidthAndTexCoord.w;\n\
 \n\
     ///////////////////////////////////////////////////////////////////////////\n\
@@ -38,11 +38,23 @@ void main()\n\
     vec4 positionEC = czm_translateRelativeToEye(positionHigh, positionLow);\n\
     vec4 prevPositionEC = czm_translateRelativeToEye(prevPositionHigh, prevPositionLow);\n\
     vec4 nextPositionEC = czm_translateRelativeToEye(nextPositionHigh, nextPositionLow);\n\
-    vec4 positionWC = getPolylineWindowCoordinates(positionEC, prevPositionEC, nextPositionEC, expandDir, width, usePrevious, polylineAngle);\n\
 #else\n\
     vec4 positionEC = czm_modelView * vec4(position, 1.0);\n\
     vec4 prevPositionEC = czm_modelView * vec4(prevPosition, 1.0);\n\
     vec4 nextPositionEC = czm_modelView * vec4(nextPosition, 1.0);\n\
+#endif\n\
+\n\
+    // A negative width is in meters; see renderBufferPolylineCollection. The quad is\n\
+    // extruded in window coordinates, so convert it at this vertex's depth.\n\
+    float width = abs(signedWidth);\n\
+    if (signedWidth < 0.0)\n\
+    {\n\
+        width /= max(czm_metersPerPixel(positionEC), czm_epsilon7);\n\
+    }\n\
+\n\
+#ifdef USE_FLOAT64\n\
+    vec4 positionWC = getPolylineWindowCoordinates(positionEC, prevPositionEC, nextPositionEC, expandDir, width, usePrevious, polylineAngle);\n\
+#else\n\
     // Positions are already in eye space; use the EC variant to skip the redundant transform.\n\
     vec4 positionWC = getPolylineWindowCoordinatesEC(positionEC, prevPositionEC, nextPositionEC, expandDir, width, usePrevious, polylineAngle);\n\
 #endif\n\

package/Source/Shaders/Builtin/CzmBuiltins.js

@@ -67,7 +67,6 @@ import czm_cascadeColor from './Functions/cascadeColor.js'
 import czm_cascadeDistance from './Functions/cascadeDistance.js'
 import czm_cascadeMatrix from './Functions/cascadeMatrix.js'
 import czm_cascadeWeights from './Functions/cascadeWeights.js'
-import czm_clipPolygons from './Functions/clipPolygons.js'
 import czm_columbusViewMorph from './Functions/columbusViewMorph.js'
 import czm_computeAtmosphereColor from './Functions/computeAtmosphereColor.js'
 import czm_computeGroundAtmosphereScattering from './Functions/computeGroundAtmosphereScattering.js'
@@ -83,6 +82,7 @@ import czm_ellipsoidContainsPoint from './Functions/ellipsoidContainsPoint.js'
 import czm_ellipsoidTextureCoordinates from './Functions/ellipsoidTextureCoordinates.js'
 import czm_equalsEpsilon from './Functions/equalsEpsilon.js'
 import czm_eyeOffset from './Functions/eyeOffset.js'
+import czm_eyeToCartographicDelta from './Functions/eyeToCartographicDelta.js'
 import czm_eyeToWindowCoordinates from './Functions/eyeToWindowCoordinates.js'
 import czm_fastApproximateAtan from './Functions/fastApproximateAtan.js'
 import czm_fog from './Functions/fog.js'
@@ -131,7 +131,6 @@ import czm_transformPlane from './Functions/transformPlane.js'
 import czm_translateRelativeToEye from './Functions/translateRelativeToEye.js'
 import czm_translucentPhong from './Functions/translucentPhong.js'
 import czm_transpose from './Functions/transpose.js'
-import czm_unpackClippingExtents from './Functions/unpackClippingExtents.js'
 import czm_unpackDepth from './Functions/unpackDepth.js'
 import czm_unpackFloat from './Functions/unpackFloat.js'
 import czm_unpackTexture from './Functions/unpackTexture.js'
@@ -212,7 +211,6 @@ export default {
     czm_cascadeDistance : czm_cascadeDistance,
     czm_cascadeMatrix : czm_cascadeMatrix,
     czm_cascadeWeights : czm_cascadeWeights,
-    czm_clipPolygons : czm_clipPolygons,
     czm_columbusViewMorph : czm_columbusViewMorph,
     czm_computeAtmosphereColor : czm_computeAtmosphereColor,
     czm_computeGroundAtmosphereScattering : czm_computeGroundAtmosphereScattering,
@@ -228,6 +226,7 @@ export default {
     czm_ellipsoidTextureCoordinates : czm_ellipsoidTextureCoordinates,
     czm_equalsEpsilon : czm_equalsEpsilon,
     czm_eyeOffset : czm_eyeOffset,
+    czm_eyeToCartographicDelta : czm_eyeToCartographicDelta,
     czm_eyeToWindowCoordinates : czm_eyeToWindowCoordinates,
     czm_fastApproximateAtan : czm_fastApproximateAtan,
     czm_fog : czm_fog,
@@ -276,7 +275,6 @@ export default {
     czm_translateRelativeToEye : czm_translateRelativeToEye,
     czm_translucentPhong : czm_translucentPhong,
     czm_transpose : czm_transpose,
-    czm_unpackClippingExtents : czm_unpackClippingExtents,
     czm_unpackDepth : czm_unpackDepth,
     czm_unpackFloat : czm_unpackFloat,
     czm_unpackTexture : czm_unpackTexture,

package/Source/Shaders/Builtin/Functions/eyeToCartographicDelta.glsl

@@ -0,0 +1,74 @@
+/**
+ * Computes the geodetic offset (delta longitude, latitude, and height) from a reference cartographic position
+ * to a point given in eye coordinates.
+ *
+ * This is designed to preserve precision. Rather than converting the point's absolute world position to
+ * cartographic -- which is too large to process precisely at 32 bits -- it works entirely with the small
+ * delta between the point and the camera. By projecting the eye-space offset onto the ellipsoid's equatorial
+ * and meridional planes, it derives the change in (longitude, latitude, height) as small, precisely-representable
+ * quantities. The delta gets smaller and more precise as one zooms in.
+ * <br /><br />
+ * This assumes an ellipsoid of revolution (equatorial radii equal, as with WGS84), so that longitude is exact.
+ * The latitude calculation is only first-order accurate, since the meridian is an ellipse rather than a circle.
+ *
+ * @name czm_eyeToCartographicDelta
+ * @glslFunction
+ *
+ * @param {vec3} positionEC The position, in eye coordinates, to measure to.
+ *
+ * @returns {vec3} The geodetic offset from the camera to <code>positionEC</code>, as (delta longitude, delta latitude in radians, delta height in meters).
+ */
+vec3 czm_eyeToCartographicDelta(vec3 positionEC)
+{
+    // A vector representing the camera-to-vertex offset, in an ENU oriented reference frame (centered at the camera)
+    vec3 cameraToVertex = czm_eyeToEnu * positionEC;
+
+    float cosLatitude = cos(czm_eyeCartographic.y);
+    float sinLatitude = sin(czm_eyeCartographic.y);
+
+    // To derive longitude, project the camera and vertex onto the equatorial plane, in a frame such that the camera lies along the +x axis. In this frame,
+    // the vertex's (delta) longitude is simply the atan of its x and y components.
+    float primeVerticalRadius = 1.0 / czm_eyeEllipsoidCurvature.x;
+    vec2 cameraEquatorialPos = vec2((primeVerticalRadius + czm_eyeCartographic.z) * cosLatitude, 0.0);
+    vec2 vertexEquatorialPos = cameraEquatorialPos + vec2(-cameraToVertex.y * sinLatitude + cameraToVertex.z * cosLatitude, cameraToVertex.x);
+    float deltaLongitude = atan(vertexEquatorialPos.y, vertexEquatorialPos.x);
+
+    // Deriving latitude is a bit harder: we can't directly project the vertex onto the camera's meridian — the latitude projection is dependent on the longitude.
+    // Instead we can rotate the vertex (by -deltaLongitude) onto the camera's meridional plane.  (Note: (unlike the exact longitude case) this is only first-order accurate because the meridian is an ellipse rather than a circle)
+    // Using a 2D rotation formula introduces precision issues (subtraction of large-magnitude quantities), so instead we can calculate the vector difference
+    // between the vertex and its rotated version, and apply that offset to the cameraToVertex vector. Then, the cameraToVertex vector accurately
+    // reflects the difference between the camera and the _rotated_ vertex, so we can then project the camera onto the meridional plane and apply this offset - just as we did for deltaLongitude, above.
+    // Best of all, we can do this all with small delta quantities which preserve precision.
+    //
+    // (I suggest drawing this out -- with the vertex and camera vectors projected onto the equatorial plane, with the camera on the +x axis)
+    // Mathematically: if you compare (subtract) vertexEquatorialPos and the same vector rotated onto the camera's meridional plane, you get
+    // |dx| = |vertexEquatorialPos| - vertexEquatorialPos.x = (r - x) = r * (1 - cos(deltaLongitude))
+    // |dy| = cameraToVertex.x (the east component)
+    // (To avoid precision issues, we'll use the identity (1 - cos(x) = 2 * sin^2(x/2)))
+    //
+    // Since these offsets were produced in the equatorial plane, and cameraToVertex is in the camera's ENU frame, we need to deconstruct along the camera's north and up axes. And we only care about
+    // dx, since dy is in the camera's east direction, and that component gets zeroed out when projecting onto the camera's meridional plane.
+    float sinHalfLongitude = sin(deltaLongitude * 0.5);
+    float dx = length(vertexEquatorialPos) * 2.0 * sinHalfLongitude * sinHalfLongitude;
+    vec3 meridionalOffset = vec3(
+        0.0,                                 // east
+        cameraToVertex.y - dx * sinLatitude, // north
+        cameraToVertex.z + dx * cosLatitude  // up
+    );
+
+    // Reframe the camera in a meridional plane, where it lies along the +z axis, and apply the meridionalOffset to get the vertex's position in that plane.
+    // Then, deltaLatitude is simply the atan of its x and y components.
+    float meridionalRadius = 1.0 / czm_eyeEllipsoidCurvature.y;
+    vec2 cameraMeridionalPos = vec2(meridionalRadius + czm_eyeCartographic.z, 0.0);
+    vec2 vertMeridionalPos = cameraMeridionalPos + vec2(meridionalOffset.z, meridionalOffset.y);
+    float deltaLatitude = atan(vertMeridionalPos.y, vertMeridionalPos.x);
+
+    // Finally, derive the change in height above the ellipsoid. This is the meridional-plane analogue of the dx step above:
+    // there we rotated the vertex (in the equatorial plane) to the camera's longitude; here we rotate it (in the meridional plane, by -deltaLatitude)
+    // to the camera's latitude, aligning it with the camera's radial (up) direction.
+    float sinHalfLatitude = sin(deltaLatitude * 0.5);
+    float dz = length(vertMeridionalPos) * 2.0 * sinHalfLatitude * sinHalfLatitude;
+    float deltaHeight = meridionalOffset.z + dz;
+
+    return vec3(deltaLongitude, deltaLatitude, deltaHeight);
+}

package/Source/Shaders/Builtin/Functions/eyeToCartographicDelta.js

@@ -0,0 +1,76 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "/**\n\
+ * Computes the geodetic offset (delta longitude, latitude, and height) from a reference cartographic position\n\
+ * to a point given in eye coordinates.\n\
+ *\n\
+ * This is designed to preserve precision. Rather than converting the point's absolute world position to\n\
+ * cartographic -- which is too large to process precisely at 32 bits -- it works entirely with the small\n\
+ * delta between the point and the camera. By projecting the eye-space offset onto the ellipsoid's equatorial\n\
+ * and meridional planes, it derives the change in (longitude, latitude, height) as small, precisely-representable\n\
+ * quantities. The delta gets smaller and more precise as one zooms in.\n\
+ * <br /><br />\n\
+ * This assumes an ellipsoid of revolution (equatorial radii equal, as with WGS84), so that longitude is exact.\n\
+ * The latitude calculation is only first-order accurate, since the meridian is an ellipse rather than a circle.\n\
+ *\n\
+ * @name czm_eyeToCartographicDelta\n\
+ * @glslFunction\n\
+ *\n\
+ * @param {vec3} positionEC The position, in eye coordinates, to measure to.\n\
+ *\n\
+ * @returns {vec3} The geodetic offset from the camera to <code>positionEC</code>, as (delta longitude, delta latitude in radians, delta height in meters).\n\
+ */\n\
+vec3 czm_eyeToCartographicDelta(vec3 positionEC)\n\
+{\n\
+    // A vector representing the camera-to-vertex offset, in an ENU oriented reference frame (centered at the camera)\n\
+    vec3 cameraToVertex = czm_eyeToEnu * positionEC;\n\
+\n\
+    float cosLatitude = cos(czm_eyeCartographic.y);\n\
+    float sinLatitude = sin(czm_eyeCartographic.y);\n\
+\n\
+    // To derive longitude, project the camera and vertex onto the equatorial plane, in a frame such that the camera lies along the +x axis. In this frame,\n\
+    // the vertex's (delta) longitude is simply the atan of its x and y components.\n\
+    float primeVerticalRadius = 1.0 / czm_eyeEllipsoidCurvature.x;\n\
+    vec2 cameraEquatorialPos = vec2((primeVerticalRadius + czm_eyeCartographic.z) * cosLatitude, 0.0);\n\
+    vec2 vertexEquatorialPos = cameraEquatorialPos + vec2(-cameraToVertex.y * sinLatitude + cameraToVertex.z * cosLatitude, cameraToVertex.x);\n\
+    float deltaLongitude = atan(vertexEquatorialPos.y, vertexEquatorialPos.x);\n\
+\n\
+    // Deriving latitude is a bit harder: we can't directly project the vertex onto the camera's meridian — the latitude projection is dependent on the longitude.\n\
+    // Instead we can rotate the vertex (by -deltaLongitude) onto the camera's meridional plane.  (Note: (unlike the exact longitude case) this is only first-order accurate because the meridian is an ellipse rather than a circle)\n\
+    // Using a 2D rotation formula introduces precision issues (subtraction of large-magnitude quantities), so instead we can calculate the vector difference\n\
+    // between the vertex and its rotated version, and apply that offset to the cameraToVertex vector. Then, the cameraToVertex vector accurately\n\
+    // reflects the difference between the camera and the _rotated_ vertex, so we can then project the camera onto the meridional plane and apply this offset - just as we did for deltaLongitude, above.\n\
+    // Best of all, we can do this all with small delta quantities which preserve precision.\n\
+    //\n\
+    // (I suggest drawing this out -- with the vertex and camera vectors projected onto the equatorial plane, with the camera on the +x axis)\n\
+    // Mathematically: if you compare (subtract) vertexEquatorialPos and the same vector rotated onto the camera's meridional plane, you get\n\
+    // |dx| = |vertexEquatorialPos| - vertexEquatorialPos.x = (r - x) = r * (1 - cos(deltaLongitude))\n\
+    // |dy| = cameraToVertex.x (the east component)\n\
+    // (To avoid precision issues, we'll use the identity (1 - cos(x) = 2 * sin^2(x/2)))\n\
+    //\n\
+    // Since these offsets were produced in the equatorial plane, and cameraToVertex is in the camera's ENU frame, we need to deconstruct along the camera's north and up axes. And we only care about\n\
+    // dx, since dy is in the camera's east direction, and that component gets zeroed out when projecting onto the camera's meridional plane.\n\
+    float sinHalfLongitude = sin(deltaLongitude * 0.5);\n\
+    float dx = length(vertexEquatorialPos) * 2.0 * sinHalfLongitude * sinHalfLongitude;\n\
+    vec3 meridionalOffset = vec3(\n\
+        0.0,                                 // east\n\
+        cameraToVertex.y - dx * sinLatitude, // north\n\
+        cameraToVertex.z + dx * cosLatitude  // up\n\
+    );\n\
+\n\
+    // Reframe the camera in a meridional plane, where it lies along the +z axis, and apply the meridionalOffset to get the vertex's position in that plane.\n\
+    // Then, deltaLatitude is simply the atan of its x and y components.\n\
+    float meridionalRadius = 1.0 / czm_eyeEllipsoidCurvature.y;\n\
+    vec2 cameraMeridionalPos = vec2(meridionalRadius + czm_eyeCartographic.z, 0.0);\n\
+    vec2 vertMeridionalPos = cameraMeridionalPos + vec2(meridionalOffset.z, meridionalOffset.y);\n\
+    float deltaLatitude = atan(vertMeridionalPos.y, vertMeridionalPos.x);\n\
+\n\
+    // Finally, derive the change in height above the ellipsoid. This is the meridional-plane analogue of the dx step above:\n\
+    // there we rotated the vertex (in the equatorial plane) to the camera's longitude; here we rotate it (in the meridional plane, by -deltaLatitude)\n\
+    // to the camera's latitude, aligning it with the camera's radial (up) direction.\n\
+    float sinHalfLatitude = sin(deltaLatitude * 0.5);\n\
+    float dz = length(vertMeridionalPos) * 2.0 * sinHalfLatitude * sinHalfLatitude;\n\
+    float deltaHeight = meridionalOffset.z + dz;\n\
+\n\
+    return vec3(deltaLongitude, deltaLatitude, deltaHeight);\n\
+}\n\
+";

package/Source/Shaders/GlobeFS.glsl

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

package/Source/Shaders/GlobeFS.js

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

package/Source/Shaders/GlobeVS.glsl

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

package/Source/Shaders/GlobeVS.js

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

package/Source/Shaders/Model/ModelClippingPolygonsStageFS.glsl

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

package/Source/Shaders/Model/ModelClippingPolygonsStageFS.js

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

package/Source/Shaders/Model/ModelClippingPolygonsStageVS.glsl

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