@cesium/engine 9.0.0 → 9.1.0

package/Source/Shaders/Builtin/CzmBuiltins.js

@@ -64,6 +64,7 @@ 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'
@@ -127,6 +128,7 @@ 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_unpackUint from './Functions/unpackUint.js'
@@ -203,6 +205,7 @@ 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,
@@ -266,6 +269,7 @@ 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_unpackUint : czm_unpackUint,

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

@@ -0,0 +1,37 @@
+float getSignedDistance(vec2 uv, highp sampler2D clippingDistance) {
+    float signedDistance = texture(clippingDistance, uv).r;
+    return (signedDistance - 0.5) * 2.0;
+}
+
+void czm_clipPolygons(highp sampler2D clippingDistance, int extentsLength, vec2 clippingPosition, int regionIndex) {
+    // Position is completely outside of polygons bounds
+    vec2 rectUv = clippingPosition;
+    if (regionIndex < 0 || rectUv.x <= 0.0 || rectUv.y <= 0.0 || rectUv.x >= 1.0 || rectUv.y >= 1.0) {
+        #ifdef CLIPPING_INVERSE 
+            discard;
+        #endif
+        return;
+    }
+
+    vec2 clippingDistanceTextureDimensions = vec2(textureSize(clippingDistance, 0));
+    vec2 sampleOffset = max(1.0 / clippingDistanceTextureDimensions, vec2(0.005));
+    float dimension = float(extentsLength);
+    if (extentsLength > 2) {
+       dimension = ceil(log2(float(extentsLength)));
+    }
+
+    vec2 textureOffset = vec2(mod(float(regionIndex), dimension), floor(float(regionIndex) / dimension)) / dimension;
+    vec2 uv = textureOffset + rectUv / dimension;
+
+    float signedDistance = getSignedDistance(uv, clippingDistance);
+
+    #ifdef CLIPPING_INVERSE
+    if (signedDistance > 0.0)  {
+        discard;
+    }
+    #else
+    if (signedDistance < 0.0)  {
+        discard;
+    }
+    #endif
+}

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

@@ -0,0 +1,39 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "float getSignedDistance(vec2 uv, highp sampler2D clippingDistance) {\n\
+    float signedDistance = texture(clippingDistance, uv).r;\n\
+    return (signedDistance - 0.5) * 2.0;\n\
+}\n\
+\n\
+void czm_clipPolygons(highp sampler2D clippingDistance, int extentsLength, vec2 clippingPosition, int regionIndex) {\n\
+    // Position is completely outside of polygons bounds\n\
+    vec2 rectUv = clippingPosition;\n\
+    if (regionIndex < 0 || rectUv.x <= 0.0 || rectUv.y <= 0.0 || rectUv.x >= 1.0 || rectUv.y >= 1.0) {\n\
+        #ifdef CLIPPING_INVERSE \n\
+            discard;\n\
+        #endif\n\
+        return;\n\
+    }\n\
+\n\
+    vec2 clippingDistanceTextureDimensions = vec2(textureSize(clippingDistance, 0));\n\
+    vec2 sampleOffset = max(1.0 / clippingDistanceTextureDimensions, vec2(0.005));\n\
+    float dimension = float(extentsLength);\n\
+    if (extentsLength > 2) {\n\
+       dimension = ceil(log2(float(extentsLength)));\n\
+    }\n\
+\n\
+    vec2 textureOffset = vec2(mod(float(regionIndex), dimension), floor(float(regionIndex) / dimension)) / dimension;\n\
+    vec2 uv = textureOffset + rectUv / dimension;\n\
+\n\
+    float signedDistance = getSignedDistance(uv, clippingDistance);\n\
+\n\
+    #ifdef CLIPPING_INVERSE\n\
+    if (signedDistance > 0.0)  {\n\
+        discard;\n\
+    }\n\
+    #else\n\
+    if (signedDistance < 0.0)  {\n\
+        discard;\n\
+    }\n\
+    #endif\n\
+}\n\
+";

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

@@ -0,0 +1,14 @@
+vec2 getLookupUv(vec2 dimensions, int i) {
+    int pixY = i / int(dimensions.x);
+    int pixX = i - (pixY * int(dimensions.x));
+    float pixelWidth = 1.0 / dimensions.x;
+    float pixelHeight = 1.0 / dimensions.y;
+    float u = (float(pixX) + 0.5) * pixelWidth; // sample from center of pixel
+    float v = (float(pixY) + 0.5) * pixelHeight;
+    return vec2(u, v);
+}
+
+vec4 czm_unpackClippingExtents(highp sampler2D extentsTexture, int index) {
+    vec2 textureDimensions = vec2(textureSize(extentsTexture, 0));
+    return texture(extentsTexture, getLookupUv(textureDimensions, index));
+}

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

@@ -0,0 +1,15 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "vec2 getLookupUv(vec2 dimensions, int i) {\n\
+    int pixY = i / int(dimensions.x);\n\
+    int pixX = i - (pixY * int(dimensions.x));\n\
+    float pixelWidth = 1.0 / dimensions.x;\n\
+    float pixelHeight = 1.0 / dimensions.y;\n\
+    float u = (float(pixX) + 0.5) * pixelWidth; // sample from center of pixel\n\
+    float v = (float(pixY) + 0.5) * pixelHeight;\n\
+    return vec2(u, v);\n\
+}\n\
+\n\
+vec4 czm_unpackClippingExtents(highp sampler2D extentsTexture, int index) {\n\
+    vec2 textureDimensions = vec2(textureSize(extentsTexture, 0));\n\
+    return texture(extentsTexture, getLookupUv(textureDimensions, index));\n\
+}";

package/Source/Shaders/GlobeFS.glsl

@@ -77,6 +77,12 @@ 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
@@ -413,6 +419,12 @@ void main()
     }
 #endif
 
+#ifdef ENABLE_CLIPPING_POLYGONS
+    vec2 clippingPosition = v_clippingPosition;
+    int regionIndex = v_regionIndex;
+    clipPolygons(u_clippingDistance, CLIPPING_POLYGON_REGIONS_LENGTH, clippingPosition, regionIndex);    
+#endif
+
 #ifdef HIGHLIGHT_FILL_TILE
     finalColor = vec4(mix(finalColor.rgb, u_fillHighlightColor.rgb, u_fillHighlightColor.a), finalColor.a);
 #endif

package/Source/Shaders/GlobeFS.js

@@ -78,6 +78,12 @@ 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\
@@ -414,6 +420,12 @@ void main()\n\
     }\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\
+#endif\n\
+\n\
 #ifdef HIGHLIGHT_FILL_TILE\n\
     finalColor = vec4(mix(finalColor.rgb, u_fillHighlightColor.rgb, u_fillHighlightColor.a), finalColor.a);\n\
 #endif\n\

package/Source/Shaders/GlobeVS.glsl

@@ -46,6 +46,12 @@ 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);
@@ -207,6 +213,32 @@ 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,6 +47,12 @@ 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\
@@ -208,6 +214,32 @@ 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/GeometryStageVS.glsl

@@ -16,7 +16,7 @@ vec4 geometryStage(inout ProcessedAttributes attributes, mat4 modelView, mat3 no
     #endif
 
     // Sometimes the custom shader and/or style needs this
-    #if defined(COMPUTE_POSITION_WC_CUSTOM_SHADER) || defined(COMPUTE_POSITION_WC_STYLE) || defined(COMPUTE_POSITION_WC_ATMOSPHERE)
+    #if defined(COMPUTE_POSITION_WC_CUSTOM_SHADER) || defined(COMPUTE_POSITION_WC_STYLE) || defined(COMPUTE_POSITION_WC_ATMOSPHERE) || defined(ENABLE_CLIPPING_POLYGONS)
     // Note that this is a 32-bit position which may result in jitter on small
     // scales.
     v_positionWC = (czm_model * vec4(positionMC, 1.0)).xyz;

package/Source/Shaders/Model/GeometryStageVS.js

@@ -17,7 +17,7 @@ export default "vec4 geometryStage(inout ProcessedAttributes attributes, mat4 mo
     #endif\n\
 \n\
     // Sometimes the custom shader and/or style needs this\n\
-    #if defined(COMPUTE_POSITION_WC_CUSTOM_SHADER) || defined(COMPUTE_POSITION_WC_STYLE) || defined(COMPUTE_POSITION_WC_ATMOSPHERE)\n\
+    #if defined(COMPUTE_POSITION_WC_CUSTOM_SHADER) || defined(COMPUTE_POSITION_WC_STYLE) || defined(COMPUTE_POSITION_WC_ATMOSPHERE) || defined(ENABLE_CLIPPING_POLYGONS)\n\
     // Note that this is a 32-bit position which may result in jitter on small\n\
     // scales.\n\
     v_positionWC = (czm_model * vec4(positionMC, 1.0)).xyz;\n\

package/Source/Shaders/Model/ModelClippingPolygonsStageFS.glsl

@@ -0,0 +1,6 @@
+void modelClippingPolygonsStage()
+{
+    vec2 clippingPosition = v_clippingPosition;
+    int regionIndex = v_regionIndex;
+    czm_clipPolygons(model_clippingDistance, CLIPPING_POLYGON_REGIONS_LENGTH, clippingPosition, regionIndex);
+}

package/Source/Shaders/Model/ModelClippingPolygonsStageFS.js

@@ -0,0 +1,8 @@
+//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\
+}\n\
+";

package/Source/Shaders/Model/ModelClippingPolygonsStageVS.glsl

@@ -0,0 +1,27 @@
+void modelClippingPolygonsStage(ProcessedAttributes attributes)
+{
+    vec2 sphericalLatLong = czm_approximateSphericalCoordinates(v_positionWC);
+    sphericalLatLong.y = czm_branchFreeTernary(sphericalLatLong.y < czm_pi, sphericalLatLong.y, sphericalLatLong.y - czm_twoPi);
+
+    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;
+        }
+    }
+}

package/Source/Shaders/Model/ModelClippingPolygonsStageVS.js

@@ -0,0 +1,29 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "void modelClippingPolygonsStage(ProcessedAttributes attributes)\n\
+{\n\
+    vec2 sphericalLatLong = czm_approximateSphericalCoordinates(v_positionWC);\n\
+    sphericalLatLong.y = czm_branchFreeTernary(sphericalLatLong.y < czm_pi, sphericalLatLong.y, sphericalLatLong.y - czm_twoPi);\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\
+}\n\
+";

package/Source/Shaders/Model/ModelFS.glsl

@@ -1,3 +1,5 @@
+
+precision highp float;
 czm_modelMaterial defaultModelMaterial()
 {
     czm_modelMaterial material;
@@ -75,6 +77,10 @@ void main()
     modelClippingPlanesStage(color);
     #endif
 
+    #ifdef ENABLE_CLIPPING_POLYGONS
+    modelClippingPolygonsStage();
+    #endif
+
     #if defined(HAS_SILHOUETTE) && defined(HAS_NORMALS)
     silhouetteStage(color);
     #endif

package/Source/Shaders/Model/ModelFS.js

@@ -1,5 +1,7 @@
 //This file is automatically rebuilt by the Cesium build process.
-export default "czm_modelMaterial defaultModelMaterial()\n\
+export default "\n\
+precision highp float;\n\
+czm_modelMaterial defaultModelMaterial()\n\
 {\n\
     czm_modelMaterial material;\n\
     material.diffuse = vec3(0.0);\n\
@@ -75,6 +77,10 @@ void main()\n\
     #ifdef HAS_CLIPPING_PLANES\n\
     modelClippingPlanesStage(color);\n\
     #endif\n\
+\n\
+    #ifdef ENABLE_CLIPPING_POLYGONS\n\
+    modelClippingPolygonsStage();\n\
+    #endif\n\
 \n\
     #if defined(HAS_SILHOUETTE) && defined(HAS_NORMALS)\n\
     silhouetteStage(color);\n\

package/Source/Shaders/Model/ModelVS.glsl

@@ -111,6 +111,10 @@ void main()
     atmosphereStage(attributes);
     #endif
 
+    #ifdef ENABLE_CLIPPING_POLYGONS
+    modelClippingPolygonsStage(attributes);
+    #endif
+
     #ifdef HAS_SILHOUETTE
     silhouetteStage(attributes, positionClip);
     #endif

package/Source/Shaders/Model/ModelVS.js

@@ -111,6 +111,10 @@ void main()\n\
     #ifdef HAS_ATMOSPHERE\n\
     atmosphereStage(attributes);\n\
     #endif\n\
+\n\
+    #ifdef ENABLE_CLIPPING_POLYGONS\n\
+    modelClippingPolygonsStage(attributes);\n\
+    #endif\n\
 \n\
     #ifdef HAS_SILHOUETTE\n\
     silhouetteStage(attributes, positionClip);\n\

package/Source/Shaders/PolygonSignedDistanceFS.glsl

@@ -0,0 +1,100 @@
+in vec2 v_textureCoordinates;
+
+uniform int u_polygonsLength;
+uniform int u_extentsLength;
+uniform highp sampler2D u_polygonTexture;
+uniform highp sampler2D u_extentsTexture;
+
+int getPolygonIndex(float dimension, vec2 coord) {
+   vec2 uv = coord.xy * dimension;
+   return int(floor(uv.y) * dimension + floor(uv.x));
+}
+
+vec2 getLookupUv(ivec2 dimensions, int i) {
+    int pixY = i / dimensions.x;
+    int pixX = i - (pixY * dimensions.x);
+    float pixelWidth = 1.0 / float(dimensions.x);
+    float pixelHeight = 1.0 / float(dimensions.y);
+    float u = (float(pixX) + 0.5) * pixelWidth; // sample from center of pixel
+    float v = (float(pixY) + 0.5) * pixelHeight;
+    return vec2(u, v);
+}
+
+vec4 getExtents(int i) {
+    return texture(u_extentsTexture, getLookupUv(textureSize(u_extentsTexture, 0), i));
+}
+
+ivec2 getPositionsLengthAndExtentsIndex(int i) {
+    vec2 uv = getLookupUv(textureSize(u_polygonTexture, 0), i);
+    vec4 value = texture(u_polygonTexture, uv);
+    return ivec2(int(value.x), int(value.y));
+}
+
+vec2 getPolygonPosition(int i) {
+    vec2 uv = getLookupUv(textureSize(u_polygonTexture, 0), i);
+    return texture(u_polygonTexture, uv).xy;
+}
+
+vec2 getCoordinates(vec2 textureCoordinates, vec4 extents) {
+    float latitude = mix(extents.x, extents.x + 1.0 / extents.z, textureCoordinates.y);
+    float longitude = mix(extents.y, extents.y + 1.0 / extents.w, textureCoordinates.x);
+    return vec2(latitude, longitude);
+}
+
+void main() {
+    int lastPolygonIndex = 0;
+    out_FragColor = vec4(1.0);
+
+    // Get the relevant region of the texture
+    float dimension = float(u_extentsLength);
+    if (u_extentsLength > 2) {
+        dimension = ceil(log2(float(u_extentsLength)));
+    }
+    int regionIndex = getPolygonIndex(dimension, v_textureCoordinates);
+
+    for (int polygonIndex = 0; polygonIndex < u_polygonsLength; polygonIndex++) {
+        ivec2 positionsLengthAndExtents = getPositionsLengthAndExtentsIndex(lastPolygonIndex);
+        int positionsLength = positionsLengthAndExtents.x;
+        int polygonExtentsIndex = positionsLengthAndExtents.y;
+        lastPolygonIndex += 1;
+
+         // Only compute signed distance for the relevant part of the atlas
+         if (polygonExtentsIndex == regionIndex) {
+            float clipAmount = czm_infinity;
+            vec4 extents = getExtents(polygonExtentsIndex);
+            vec2 textureOffset = vec2(mod(float(polygonExtentsIndex), dimension), floor(float(polygonExtentsIndex) / dimension)) / dimension;
+            vec2 p = getCoordinates((v_textureCoordinates - textureOffset) * dimension, extents);
+            float s = 1.0;
+
+            // Check each edge for absolute distance
+            for (int i = 0, j = positionsLength - 1; i < positionsLength; j = i, i++) {
+                vec2 a = getPolygonPosition(lastPolygonIndex + i);
+                vec2 b = getPolygonPosition(lastPolygonIndex + j);
+ 
+                vec2 ab = b - a;
+                vec2 pa = p - a;
+                float t = dot(pa, ab) / dot(ab, ab);
+                t = clamp(t, 0.0, 1.0);
+
+                vec2 pq = pa - t * ab;
+                float d = length(pq);
+
+                // Inside / outside computation to determine sign
+                bvec3 cond = bvec3(p.y >= a.y, 
+                            p.y < b.y, 
+                            ab.x * pa.y > ab.y * pa.x);
+                if (all(cond) || all(not(cond))) s = -s;
+                if (abs(d) < abs(clipAmount)) {
+                    clipAmount = d;
+                }
+            }
+
+            // Normalize the range to [0,1]
+            vec4 result = (s * vec4(clipAmount * length(extents.zw))) / 2.0 + 0.5;
+            // In the case where we've iterated through multiple polygons, take the minimum
+            out_FragColor = min(out_FragColor, result);
+         }
+
+        lastPolygonIndex += positionsLength;
+    }
+}

package/Source/Shaders/PolygonSignedDistanceFS.js

@@ -0,0 +1,101 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "in vec2 v_textureCoordinates;\n\
+\n\
+uniform int u_polygonsLength;\n\
+uniform int u_extentsLength;\n\
+uniform highp sampler2D u_polygonTexture;\n\
+uniform highp sampler2D u_extentsTexture;\n\
+\n\
+int getPolygonIndex(float dimension, vec2 coord) {\n\
+   vec2 uv = coord.xy * dimension;\n\
+   return int(floor(uv.y) * dimension + floor(uv.x));\n\
+}\n\
+\n\
+vec2 getLookupUv(ivec2 dimensions, int i) {\n\
+    int pixY = i / dimensions.x;\n\
+    int pixX = i - (pixY * dimensions.x);\n\
+    float pixelWidth = 1.0 / float(dimensions.x);\n\
+    float pixelHeight = 1.0 / float(dimensions.y);\n\
+    float u = (float(pixX) + 0.5) * pixelWidth; // sample from center of pixel\n\
+    float v = (float(pixY) + 0.5) * pixelHeight;\n\
+    return vec2(u, v);\n\
+}\n\
+\n\
+vec4 getExtents(int i) {\n\
+    return texture(u_extentsTexture, getLookupUv(textureSize(u_extentsTexture, 0), i));\n\
+}\n\
+\n\
+ivec2 getPositionsLengthAndExtentsIndex(int i) {\n\
+    vec2 uv = getLookupUv(textureSize(u_polygonTexture, 0), i);\n\
+    vec4 value = texture(u_polygonTexture, uv);\n\
+    return ivec2(int(value.x), int(value.y));\n\
+}\n\
+\n\
+vec2 getPolygonPosition(int i) {\n\
+    vec2 uv = getLookupUv(textureSize(u_polygonTexture, 0), i);\n\
+    return texture(u_polygonTexture, uv).xy;\n\
+}\n\
+\n\
+vec2 getCoordinates(vec2 textureCoordinates, vec4 extents) {\n\
+    float latitude = mix(extents.x, extents.x + 1.0 / extents.z, textureCoordinates.y);\n\
+    float longitude = mix(extents.y, extents.y + 1.0 / extents.w, textureCoordinates.x);\n\
+    return vec2(latitude, longitude);\n\
+}\n\
+\n\
+void main() {\n\
+    int lastPolygonIndex = 0;\n\
+    out_FragColor = vec4(1.0);\n\
+\n\
+    // Get the relevant region of the texture\n\
+    float dimension = float(u_extentsLength);\n\
+    if (u_extentsLength > 2) {\n\
+        dimension = ceil(log2(float(u_extentsLength)));\n\
+    }\n\
+    int regionIndex = getPolygonIndex(dimension, v_textureCoordinates);\n\
+\n\
+    for (int polygonIndex = 0; polygonIndex < u_polygonsLength; polygonIndex++) {\n\
+        ivec2 positionsLengthAndExtents = getPositionsLengthAndExtentsIndex(lastPolygonIndex);\n\
+        int positionsLength = positionsLengthAndExtents.x;\n\
+        int polygonExtentsIndex = positionsLengthAndExtents.y;\n\
+        lastPolygonIndex += 1;\n\
+\n\
+         // Only compute signed distance for the relevant part of the atlas\n\
+         if (polygonExtentsIndex == regionIndex) {\n\
+            float clipAmount = czm_infinity;\n\
+            vec4 extents = getExtents(polygonExtentsIndex);\n\
+            vec2 textureOffset = vec2(mod(float(polygonExtentsIndex), dimension), floor(float(polygonExtentsIndex) / dimension)) / dimension;\n\
+            vec2 p = getCoordinates((v_textureCoordinates - textureOffset) * dimension, extents);\n\
+            float s = 1.0;\n\
+\n\
+            // Check each edge for absolute distance\n\
+            for (int i = 0, j = positionsLength - 1; i < positionsLength; j = i, i++) {\n\
+                vec2 a = getPolygonPosition(lastPolygonIndex + i);\n\
+                vec2 b = getPolygonPosition(lastPolygonIndex + j);\n\
+ \n\
+                vec2 ab = b - a;\n\
+                vec2 pa = p - a;\n\
+                float t = dot(pa, ab) / dot(ab, ab);\n\
+                t = clamp(t, 0.0, 1.0);\n\
+\n\
+                vec2 pq = pa - t * ab;\n\
+                float d = length(pq);\n\
+\n\
+                // Inside / outside computation to determine sign\n\
+                bvec3 cond = bvec3(p.y >= a.y, \n\
+                            p.y < b.y, \n\
+                            ab.x * pa.y > ab.y * pa.x);\n\
+                if (all(cond) || all(not(cond))) s = -s;\n\
+                if (abs(d) < abs(clipAmount)) {\n\
+                    clipAmount = d;\n\
+                }\n\
+            }\n\
+\n\
+            // Normalize the range to [0,1]\n\
+            vec4 result = (s * vec4(clipAmount * length(extents.zw))) / 2.0 + 0.5;\n\
+            // In the case where we've iterated through multiple polygons, take the minimum\n\
+            out_FragColor = min(out_FragColor, result);\n\
+         }\n\
+\n\
+        lastPolygonIndex += positionsLength;\n\
+    }\n\
+}";