@cesium/engine 26.2.0 → 26.3.0

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;
 }

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\
+";