@cesium/engine 23.0.0 → 24.0.0

package/Source/Shaders/BillboardCollectionFS.js

@@ -21,16 +21,6 @@ in vec4 v_compressed;                               // x: eyeDepth, y: applyTran
 const float SHIFT_LEFT1 = 2.0;\n\
 const float SHIFT_RIGHT1 = 1.0 / 2.0;\n\
 \n\
-#ifdef FS_THREE_POINT_DEPTH_CHECK\n\
-in vec4 v_textureCoordinateBounds;                  // the min and max x and y values for the texture coordinates\n\
-in vec4 v_originTextureCoordinateAndTranslate;      // texture coordinate at the origin, billboard translate (used for label glyphs)\n\
-in mat2 v_rotationMatrix;\n\
-\n\
-const float SHIFT_LEFT12 = 4096.0;\n\
-\n\
-const float SHIFT_RIGHT12 = 1.0 / 4096.0;\n\
-#endif\n\
-\n\
 float getGlobeDepthAtCoords(vec2 st)\n\
 {\n\
     float logDepthOrDepth = czm_unpackDepth(texture(czm_globeDepthTexture, st));\n\
@@ -43,27 +33,6 @@ float getGlobeDepthAtCoords(vec2 st)\n\
     return eyeCoordinate.z / eyeCoordinate.w;\n\
 }\n\
 \n\
-#ifdef FS_THREE_POINT_DEPTH_CHECK\n\
-float getGlobeDepth(vec2 adjustedST, vec2 depthLookupST, bool applyTranslate, vec2 dimensions, vec2 imageSize)\n\
-{\n\
-    vec2 lookupVector = imageSize * (depthLookupST - adjustedST);\n\
-    lookupVector = v_rotationMatrix * lookupVector;\n\
-    vec2 labelOffset = (dimensions - imageSize) * (depthLookupST - vec2(0.0, v_originTextureCoordinateAndTranslate.y)); // aligns label glyph with bounding rectangle.  Will be zero for billboards because dimensions and imageSize will be equal\n\
-\n\
-    vec2 translation = v_originTextureCoordinateAndTranslate.zw;\n\
-\n\
-    if (applyTranslate)\n\
-    {\n\
-        // this is only needed for labels where the horizontal origin is not LEFT\n\
-        // it moves the label back to where the \"origin\" should be since all label glyphs are set to HorizontalOrigin.LEFT\n\
-        translation += (dimensions * v_originTextureCoordinateAndTranslate.xy * vec2(1.0, 0.0));\n\
-    }\n\
-\n\
-    vec2 st = ((lookupVector - translation + labelOffset) + gl_FragCoord.xy) / czm_viewport.zw;\n\
-    return getGlobeDepthAtCoords(st);\n\
-}\n\
-#endif\n\
-\n\
 #ifdef SDF\n\
 \n\
 // Get the distance from the edge of a glyph at a given position sampling an SDF texture.\n\
@@ -94,44 +63,6 @@ vec4 getSDFColor(vec2 position, float outlineWidth, vec4 outlineColor, float smo
 }\n\
 #endif\n\
 \n\
-#ifdef FS_THREE_POINT_DEPTH_CHECK\n\
-void doThreePointDepthTest(float eyeDepth, bool applyTranslate) {\n\
-\n\
-    if (eyeDepth < -u_threePointDepthTestDistance) return;\n\
-    float temp = v_compressed.z;\n\
-    temp = temp * SHIFT_RIGHT12;\n\
-\n\
-    vec2 dimensions;\n\
-    dimensions.y = (temp - floor(temp)) * SHIFT_LEFT12;\n\
-    dimensions.x = floor(temp);\n\
-\n\
-    temp = v_compressed.w;\n\
-    temp = temp * SHIFT_RIGHT12;\n\
-\n\
-    vec2 imageSize;\n\
-    imageSize.y = (temp - floor(temp)) * SHIFT_LEFT12;\n\
-    imageSize.x = floor(temp);\n\
-\n\
-    vec2 adjustedST = v_textureCoordinates - v_textureCoordinateBounds.xy;\n\
-    adjustedST = adjustedST / vec2(v_textureCoordinateBounds.z - v_textureCoordinateBounds.x, v_textureCoordinateBounds.w - v_textureCoordinateBounds.y);\n\
-\n\
-    float epsilonEyeDepth = v_compressed.x + czm_epsilon1;\n\
-    float globeDepth1 = getGlobeDepth(adjustedST, v_originTextureCoordinateAndTranslate.xy, applyTranslate, dimensions, imageSize);\n\
-\n\
-    // negative values go into the screen\n\
-    if (globeDepth1 == 0.0 || globeDepth1 < epsilonEyeDepth) return;\n\
-\n\
-    float globeDepth2 = getGlobeDepth(adjustedST, vec2(0.0, 1.0), applyTranslate, dimensions, imageSize); // top left corner\n\
-    if (globeDepth2 == 0.0 || globeDepth2 < epsilonEyeDepth) return;\n\
-\n\
-    float globeDepth3 = getGlobeDepth(adjustedST, vec2(1.0, 1.0), applyTranslate, dimensions, imageSize); // top right corner\n\
-    if (globeDepth3 == 0.0 || globeDepth3 < epsilonEyeDepth) return;\n\
-\n\
-    // All three key points are occluded, discard the fragment (and by extension the entire billboard)\n\
-    discard;\n\
-}\n\
-#endif\n\
-\n\
 bool getDepthTestEnabled() {\n\
     float temp = v_compressed.y;\n\
     temp = temp * SHIFT_RIGHT1;\n\
@@ -154,13 +85,7 @@ float getRelativeEyeDepth(float eyeDepth, float distanceToEllipsoid, float epsil
 // by the globe when near and far from the camera.\n\
 void doDepthTest(float eyeDepth, float globeDepth) {\n\
 \n\
-#ifdef FS_THREE_POINT_DEPTH_CHECK\n\
-    // If the billboard is clamped to the ground and within a given distance, we do a 3-point depth test. This test is performed in the vertex shader, unless\n\
-    // vertex texture sampling is not supported, in which case we do it here.\n\
-    bool applyTranslate = floor(temp) != 0.0;\n\
-    doThreePointDepthTest(eyeDepth, applyTranslate);\n\
-\n\
-#elif defined(VS_THREE_POINT_DEPTH_CHECK)\n\
+#ifdef VS_THREE_POINT_DEPTH_CHECK\n\
     // Since discarding vertices is not possible, the vertex shader sets eyeDepth to 0 to indicate the depth test failed. Apply the discard here.\n\
     if (eyeDepth > -u_threePointDepthTestDistance) {\n\
         if (eyeDepth == 0.0) {\n\
@@ -189,7 +114,7 @@ void writeDepth(float eyeDepth, float globeDepth, float distanceToEllipsoid) {\n
 \n\
     float depthArg = v_depthFromNearPlusOne;\n\
 \n\
-    if (globeDepth != 0.0 && getRelativeEyeDepth(eyeDepth, distanceToEllipsoid, czm_epsilon3) > 0.0) { \n\
+    if (globeDepth != 0.0 && getRelativeEyeDepth(eyeDepth, distanceToEllipsoid, czm_epsilon3) > 0.0) {\n\
         float globeDepthFromNearPlusOne = (-globeDepth - czm_currentFrustum.x) + 1.0;\n\
         float nudge = max(globeDepthFromNearPlusOne * 5e-6, czm_epsilon7);\n\
         float globeOnTop = max(1.0, globeDepthFromNearPlusOne - nudge);\n\

package/Source/Shaders/BillboardCollectionVS.glsl

@@ -1,7 +1,5 @@
 uniform float u_threePointDepthTestDistance;
-#ifdef INSTANCED
 in vec2 direction;
-#endif
 in vec4 positionHighAndScale;
 in vec4 positionLowAndRotation;
 in vec4 compressedAttribute0;                       // pixel offset, translate, horizontal origin, vertical origin, show, direction, texture coordinates (texture offset)
@@ -13,7 +11,7 @@ in vec4 pixelOffsetScaleByDistance;                 // near, nearScale, far, far
 in vec4 compressedAttribute3;                       // distance display condition near, far, disableDepthTestDistanceSq, dimensions
 in vec2 sdf;                                        // sdf outline color (rgb) and width (w)
 in float splitDirection;                            // splitDirection
-#if defined(VS_THREE_POINT_DEPTH_CHECK) || defined(FS_THREE_POINT_DEPTH_CHECK)
+#ifdef VS_THREE_POINT_DEPTH_CHECK
 in vec4 textureCoordinateBoundsOrLabelTranslate;    // the min and max x and y values for the texture coordinates
 #endif
 #ifdef VECTOR_TILE
@@ -21,11 +19,6 @@ in float a_batchId;
 #endif
 
 out vec2 v_textureCoordinates;
-#ifdef FS_THREE_POINT_DEPTH_CHECK
-out vec4 v_textureCoordinateBounds;
-out vec4 v_originTextureCoordinateAndTranslate;
-out mat2 v_rotationMatrix;
-#endif
 out vec4 v_compressed;             // x: eyeDepth, y: applyTranslate & enableDepthCheck, z: dimensions, w: imageSize
 
 out vec4 v_pickColor;
@@ -138,25 +131,14 @@ void main()
     origin.y = floor(compressed * SHIFT_RIGHT3);
     compressed -= origin.y * SHIFT_LEFT3;
 
-#ifdef FS_THREE_POINT_DEPTH_CHECK
-    vec2 depthOrigin = origin.xy;
-#endif
     origin -= vec2(1.0);
 
     float show = floor(compressed * SHIFT_RIGHT2);
     compressed -= show * SHIFT_LEFT2;
 
-#ifdef INSTANCED
     vec2 textureCoordinatesBottomLeft = czm_decompressTextureCoordinates(compressedAttribute0.w);
     vec2 textureCoordinatesRange = czm_decompressTextureCoordinates(eyeOffset.w);
     vec2 textureCoordinates = textureCoordinatesBottomLeft + direction * textureCoordinatesRange;
-#else
-    vec2 direction;
-    direction.x = floor(compressed * SHIFT_RIGHT1);
-    direction.y = compressed - direction.x * SHIFT_LEFT1;
-
-    vec2 textureCoordinates = czm_decompressTextureCoordinates(compressedAttribute0.w);
-#endif
 
     float temp = compressedAttribute0.y  * SHIFT_RIGHT8;
     pixelOffset.y = -(floor(temp) - UPPER_BOUND);
@@ -177,19 +159,6 @@ void main()
 
     vec2 imageSize = vec2(floor(temp), temp2);
 
-#ifdef FS_THREE_POINT_DEPTH_CHECK
-    float labelHorizontalOrigin = floor(compressedAttribute2.w - (temp2 * SHIFT_LEFT2));
-    float applyTranslate = 0.0;
-    if (labelHorizontalOrigin != 0.0) // is a label, so set apply translate to true
-    {
-        applyTranslate = 1.0;
-        labelHorizontalOrigin -= 2.0;
-        depthOrigin.x = labelHorizontalOrigin + 1.0;
-    }
-
-    depthOrigin = vec2(1.0) - (depthOrigin * 0.5);
-#endif
-
 #ifdef EYE_DISTANCE_TRANSLUCENCY
     vec4 translucencyByDistance;
     translucencyByDistance.x = compressedAttribute1.z;
@@ -201,7 +170,7 @@ void main()
     translucencyByDistance.w = ((temp - floor(temp)) * SHIFT_LEFT8) / 255.0;
 #endif
 
-#if defined(VS_THREE_POINT_DEPTH_CHECK) || defined(FS_THREE_POINT_DEPTH_CHECK)
+#ifdef VS_THREE_POINT_DEPTH_CHECK
     temp = compressedAttribute3.w;
     temp = temp * SHIFT_RIGHT12;
 
@@ -384,33 +353,6 @@ if (lengthSq < (u_threePointDepthTestDistance * u_threePointDepthTestDistance) &
     }
 #endif
 
-#ifdef FS_THREE_POINT_DEPTH_CHECK
-    if (sizeInMeters) {
-        translate /= mpp;
-        dimensions /= mpp;
-        imageSize /= mpp;
-    }
-
-#if defined(ROTATION) || defined(ALIGNED_AXIS)
-    v_rotationMatrix = rotationMatrix;
-#else
-    v_rotationMatrix = mat2(1.0, 0.0, 0.0, 1.0);
-#endif
-    float dw = floor(clamp(dimensions.x, 0.0, SHIFT_LEFT12));
-    float dh = floor(clamp(dimensions.y, 0.0, SHIFT_LEFT12));
-
-    float iw = floor(clamp(imageSize.x, 0.0, SHIFT_LEFT12));
-    float ih = floor(clamp(imageSize.y, 0.0, SHIFT_LEFT12));
-
-    v_compressed.y += applyTranslate * SHIFT_LEFT1;
-    v_compressed.z = dw * SHIFT_LEFT12 + dh;
-    v_compressed.w = iw * SHIFT_LEFT12 + ih;
-    v_originTextureCoordinateAndTranslate.xy = depthOrigin;
-    v_originTextureCoordinateAndTranslate.zw = translate;
-    v_textureCoordinateBounds = textureCoordinateBoundsOrLabelTranslate;
-
-#endif
-
 #ifdef SDF
     vec4 outlineColor = czm_decodeRGB8(sdf.x);
     float outlineWidth;

package/Source/Shaders/BillboardCollectionVS.js

@@ -1,8 +1,6 @@
 //This file is automatically rebuilt by the Cesium build process.
 export default "uniform float u_threePointDepthTestDistance;\n\
-#ifdef INSTANCED\n\
 in vec2 direction;\n\
-#endif\n\
 in vec4 positionHighAndScale;\n\
 in vec4 positionLowAndRotation;\n\
 in vec4 compressedAttribute0;                       // pixel offset, translate, horizontal origin, vertical origin, show, direction, texture coordinates (texture offset)\n\
@@ -14,7 +12,7 @@ in vec4 pixelOffsetScaleByDistance;                 // near, nearScale, far, far
 in vec4 compressedAttribute3;                       // distance display condition near, far, disableDepthTestDistanceSq, dimensions\n\
 in vec2 sdf;                                        // sdf outline color (rgb) and width (w)\n\
 in float splitDirection;                            // splitDirection\n\
-#if defined(VS_THREE_POINT_DEPTH_CHECK) || defined(FS_THREE_POINT_DEPTH_CHECK)\n\
+#ifdef VS_THREE_POINT_DEPTH_CHECK\n\
 in vec4 textureCoordinateBoundsOrLabelTranslate;    // the min and max x and y values for the texture coordinates\n\
 #endif\n\
 #ifdef VECTOR_TILE\n\
@@ -22,11 +20,6 @@ in float a_batchId;\n\
 #endif\n\
 \n\
 out vec2 v_textureCoordinates;\n\
-#ifdef FS_THREE_POINT_DEPTH_CHECK\n\
-out vec4 v_textureCoordinateBounds;\n\
-out vec4 v_originTextureCoordinateAndTranslate;\n\
-out mat2 v_rotationMatrix;\n\
-#endif\n\
 out vec4 v_compressed;             // x: eyeDepth, y: applyTranslate & enableDepthCheck, z: dimensions, w: imageSize\n\
 \n\
 out vec4 v_pickColor;\n\
@@ -139,25 +132,14 @@ void main()\n\
     origin.y = floor(compressed * SHIFT_RIGHT3);\n\
     compressed -= origin.y * SHIFT_LEFT3;\n\
 \n\
-#ifdef FS_THREE_POINT_DEPTH_CHECK\n\
-    vec2 depthOrigin = origin.xy;\n\
-#endif\n\
     origin -= vec2(1.0);\n\
 \n\
     float show = floor(compressed * SHIFT_RIGHT2);\n\
     compressed -= show * SHIFT_LEFT2;\n\
 \n\
-#ifdef INSTANCED\n\
     vec2 textureCoordinatesBottomLeft = czm_decompressTextureCoordinates(compressedAttribute0.w);\n\
     vec2 textureCoordinatesRange = czm_decompressTextureCoordinates(eyeOffset.w);\n\
     vec2 textureCoordinates = textureCoordinatesBottomLeft + direction * textureCoordinatesRange;\n\
-#else\n\
-    vec2 direction;\n\
-    direction.x = floor(compressed * SHIFT_RIGHT1);\n\
-    direction.y = compressed - direction.x * SHIFT_LEFT1;\n\
-\n\
-    vec2 textureCoordinates = czm_decompressTextureCoordinates(compressedAttribute0.w);\n\
-#endif\n\
 \n\
     float temp = compressedAttribute0.y  * SHIFT_RIGHT8;\n\
     pixelOffset.y = -(floor(temp) - UPPER_BOUND);\n\
@@ -178,19 +160,6 @@ void main()\n\
 \n\
     vec2 imageSize = vec2(floor(temp), temp2);\n\
 \n\
-#ifdef FS_THREE_POINT_DEPTH_CHECK\n\
-    float labelHorizontalOrigin = floor(compressedAttribute2.w - (temp2 * SHIFT_LEFT2));\n\
-    float applyTranslate = 0.0;\n\
-    if (labelHorizontalOrigin != 0.0) // is a label, so set apply translate to true\n\
-    {\n\
-        applyTranslate = 1.0;\n\
-        labelHorizontalOrigin -= 2.0;\n\
-        depthOrigin.x = labelHorizontalOrigin + 1.0;\n\
-    }\n\
-\n\
-    depthOrigin = vec2(1.0) - (depthOrigin * 0.5);\n\
-#endif\n\
-\n\
 #ifdef EYE_DISTANCE_TRANSLUCENCY\n\
     vec4 translucencyByDistance;\n\
     translucencyByDistance.x = compressedAttribute1.z;\n\
@@ -202,7 +171,7 @@ void main()\n\
     translucencyByDistance.w = ((temp - floor(temp)) * SHIFT_LEFT8) / 255.0;\n\
 #endif\n\
 \n\
-#if defined(VS_THREE_POINT_DEPTH_CHECK) || defined(FS_THREE_POINT_DEPTH_CHECK)\n\
+#ifdef VS_THREE_POINT_DEPTH_CHECK\n\
     temp = compressedAttribute3.w;\n\
     temp = temp * SHIFT_RIGHT12;\n\
 \n\
@@ -385,33 +354,6 @@ if (lengthSq < (u_threePointDepthTestDistance * u_threePointDepthTestDistance) &
     }\n\
 #endif\n\
 \n\
-#ifdef FS_THREE_POINT_DEPTH_CHECK\n\
-    if (sizeInMeters) {\n\
-        translate /= mpp;\n\
-        dimensions /= mpp;\n\
-        imageSize /= mpp;\n\
-    }\n\
-\n\
-#if defined(ROTATION) || defined(ALIGNED_AXIS)\n\
-    v_rotationMatrix = rotationMatrix;\n\
-#else\n\
-    v_rotationMatrix = mat2(1.0, 0.0, 0.0, 1.0);\n\
-#endif\n\
-    float dw = floor(clamp(dimensions.x, 0.0, SHIFT_LEFT12));\n\
-    float dh = floor(clamp(dimensions.y, 0.0, SHIFT_LEFT12));\n\
-\n\
-    float iw = floor(clamp(imageSize.x, 0.0, SHIFT_LEFT12));\n\
-    float ih = floor(clamp(imageSize.y, 0.0, SHIFT_LEFT12));\n\
-\n\
-    v_compressed.y += applyTranslate * SHIFT_LEFT1;\n\
-    v_compressed.z = dw * SHIFT_LEFT12 + dh;\n\
-    v_compressed.w = iw * SHIFT_LEFT12 + ih;\n\
-    v_originTextureCoordinateAndTranslate.xy = depthOrigin;\n\
-    v_originTextureCoordinateAndTranslate.zw = translate;\n\
-    v_textureCoordinateBounds = textureCoordinateBoundsOrLabelTranslate;\n\
-\n\
-#endif\n\
-\n\
 #ifdef SDF\n\
     vec4 outlineColor = czm_decodeRGB8(sdf.x);\n\
     float outlineWidth;\n\

package/Source/Shaders/BufferPointMaterialFS.glsl

@@ -0,0 +1,27 @@
+in vec4 v_pickColor;
+in vec4 v_color;
+in vec4 v_outlineColor;
+in float v_innerRadiusFrac;
+
+void main()
+{
+    // Distance between fragment and point center, 0 to 0.5.
+    float distanceToCenter = length(gl_PointCoord - vec2(0.5));
+    float delta = fwidth(distanceToCenter);
+
+    float outerLimit = 0.5;
+    float innerLimit = 0.5 * v_innerRadiusFrac;
+
+    float outerAlpha = 1.0 - smoothstep(max(0.0, outerLimit - delta), outerLimit, distanceToCenter);
+    float innerAlpha = 1.0 - smoothstep(innerLimit - delta, innerLimit, distanceToCenter);
+
+    vec4 color = vec4(mix(v_outlineColor.rgb, v_color.rgb, innerAlpha), outerAlpha);
+
+    if (color.a < 0.005)   // matches 0/255 and 1/255
+    {
+        discard;
+    }
+
+    out_FragColor = czm_gammaCorrect(color);
+    czm_writeLogDepth();
+}

package/Source/Shaders/BufferPointMaterialFS.js

@@ -0,0 +1,29 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "in vec4 v_pickColor;\n\
+in vec4 v_color;\n\
+in vec4 v_outlineColor;\n\
+in float v_innerRadiusFrac;\n\
+\n\
+void main()\n\
+{\n\
+    // Distance between fragment and point center, 0 to 0.5.\n\
+    float distanceToCenter = length(gl_PointCoord - vec2(0.5));\n\
+    float delta = fwidth(distanceToCenter);\n\
+\n\
+    float outerLimit = 0.5;\n\
+    float innerLimit = 0.5 * v_innerRadiusFrac;\n\
+\n\
+    float outerAlpha = 1.0 - smoothstep(max(0.0, outerLimit - delta), outerLimit, distanceToCenter);\n\
+    float innerAlpha = 1.0 - smoothstep(innerLimit - delta, innerLimit, distanceToCenter);\n\
+\n\
+    vec4 color = vec4(mix(v_outlineColor.rgb, v_color.rgb, innerAlpha), outerAlpha);\n\
+\n\
+    if (color.a < 0.005)   // matches 0/255 and 1/255\n\
+    {\n\
+        discard;\n\
+    }\n\
+\n\
+    out_FragColor = czm_gammaCorrect(color);\n\
+    czm_writeLogDepth();\n\
+}\n\
+";

package/Source/Shaders/BufferPointMaterialVS.glsl

@@ -0,0 +1,48 @@
+in vec3 positionHigh;
+in vec3 positionLow;
+in vec4 pickColor;
+in vec3 showPixelSizeAndColor;
+in vec2 outlineWidthAndOutlineColor;
+
+out vec4 v_pickColor;
+out vec4 v_color;
+out vec4 v_outlineColor;
+out float v_innerRadiusFrac;
+
+void main()
+{
+    // Unpack attributes.
+    float show = showPixelSizeAndColor.x;
+    float pixelSize = showPixelSizeAndColor.y;
+    vec4 color = czm_decodeRGB8(showPixelSizeAndColor.z);
+    float outlineWidth = outlineWidthAndOutlineColor.x;
+    vec4 outlineColor = czm_decodeRGB8(outlineWidthAndOutlineColor.y);
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    float innerRadius = 0.5 * pixelSize * czm_pixelRatio;
+    float outerRadius = (0.5 * pixelSize + outlineWidth) * czm_pixelRatio;
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    vec4 p = czm_translateRelativeToEye(positionHigh, positionLow);
+    vec4 positionEC = czm_modelViewRelativeToEye * p;
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    gl_Position = czm_projection * positionEC;
+    czm_vertexLogDepth();
+
+    v_pickColor = pickColor / 255.0;
+
+    v_color = color;
+    v_color.a *= show;
+
+    v_outlineColor = outlineColor;
+    v_outlineColor.a *= show;
+
+    v_innerRadiusFrac = innerRadius / outerRadius;
+
+    gl_PointSize = 2.0 * outerRadius * show;
+    gl_Position *= show;
+}

package/Source/Shaders/BufferPointMaterialVS.js

@@ -0,0 +1,50 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "in vec3 positionHigh;\n\
+in vec3 positionLow;\n\
+in vec4 pickColor;\n\
+in vec3 showPixelSizeAndColor;\n\
+in vec2 outlineWidthAndOutlineColor;\n\
+\n\
+out vec4 v_pickColor;\n\
+out vec4 v_color;\n\
+out vec4 v_outlineColor;\n\
+out float v_innerRadiusFrac;\n\
+\n\
+void main()\n\
+{\n\
+    // Unpack attributes.\n\
+    float show = showPixelSizeAndColor.x;\n\
+    float pixelSize = showPixelSizeAndColor.y;\n\
+    vec4 color = czm_decodeRGB8(showPixelSizeAndColor.z);\n\
+    float outlineWidth = outlineWidthAndOutlineColor.x;\n\
+    vec4 outlineColor = czm_decodeRGB8(outlineWidthAndOutlineColor.y);\n\
+\n\
+    ///////////////////////////////////////////////////////////////////////////\n\
+\n\
+    float innerRadius = 0.5 * pixelSize * czm_pixelRatio;\n\
+    float outerRadius = (0.5 * pixelSize + outlineWidth) * czm_pixelRatio;\n\
+\n\
+    ///////////////////////////////////////////////////////////////////////////\n\
+\n\
+    vec4 p = czm_translateRelativeToEye(positionHigh, positionLow);\n\
+    vec4 positionEC = czm_modelViewRelativeToEye * p;\n\
+\n\
+    ///////////////////////////////////////////////////////////////////////////\n\
+\n\
+    gl_Position = czm_projection * positionEC;\n\
+    czm_vertexLogDepth();\n\
+\n\
+    v_pickColor = pickColor / 255.0;\n\
+\n\
+    v_color = color;\n\
+    v_color.a *= show;\n\
+\n\
+    v_outlineColor = outlineColor;\n\
+    v_outlineColor.a *= show;\n\
+\n\
+    v_innerRadiusFrac = innerRadius / outerRadius;\n\
+\n\
+    gl_PointSize = 2.0 * outerRadius * show;\n\
+    gl_Position *= show;\n\
+}\n\
+";

package/Source/Shaders/BufferPolygonMaterialFS.glsl

@@ -0,0 +1,13 @@
+in vec4 v_pickColor;
+in vec4 v_color;
+
+void main()
+{
+    if (v_color.a < 0.005)   // matches 0/255 and 1/255
+    {
+        discard;
+    }
+
+    out_FragColor = czm_gammaCorrect(v_color);
+    czm_writeLogDepth();
+}

package/Source/Shaders/BufferPolygonMaterialFS.js

@@ -0,0 +1,15 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "in vec4 v_pickColor;\n\
+in vec4 v_color;\n\
+\n\
+void main()\n\
+{\n\
+    if (v_color.a < 0.005)   // matches 0/255 and 1/255\n\
+    {\n\
+        discard;\n\
+    }\n\
+\n\
+    out_FragColor = czm_gammaCorrect(v_color);\n\
+    czm_writeLogDepth();\n\
+}\n\
+";

package/Source/Shaders/BufferPolygonMaterialVS.glsl

@@ -0,0 +1,30 @@
+in vec3 positionHigh;
+in vec3 positionLow;
+in vec4 pickColor;
+in vec2 showAndColor;
+
+out vec4 v_pickColor;
+out vec4 v_color;
+
+void main()
+{
+    float show = showAndColor.x;
+    vec4 color = czm_decodeRGB8(showAndColor.y);
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    vec4 p = czm_translateRelativeToEye(positionHigh, positionLow);
+    vec4 positionEC = czm_modelViewRelativeToEye * p;
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    gl_Position = czm_projection * positionEC;
+    czm_vertexLogDepth();
+
+    v_pickColor = pickColor / 255.0;
+
+    v_color = color;
+    v_color.a *= show;
+
+    gl_Position *= show;
+}

package/Source/Shaders/BufferPolygonMaterialVS.js

@@ -0,0 +1,32 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "in vec3 positionHigh;\n\
+in vec3 positionLow;\n\
+in vec4 pickColor;\n\
+in vec2 showAndColor;\n\
+\n\
+out vec4 v_pickColor;\n\
+out vec4 v_color;\n\
+\n\
+void main()\n\
+{\n\
+    float show = showAndColor.x;\n\
+    vec4 color = czm_decodeRGB8(showAndColor.y);\n\
+\n\
+    ///////////////////////////////////////////////////////////////////////////\n\
+\n\
+    vec4 p = czm_translateRelativeToEye(positionHigh, positionLow);\n\
+    vec4 positionEC = czm_modelViewRelativeToEye * p;\n\
+\n\
+    ///////////////////////////////////////////////////////////////////////////\n\
+\n\
+    gl_Position = czm_projection * positionEC;\n\
+    czm_vertexLogDepth();\n\
+\n\
+    v_pickColor = pickColor / 255.0;\n\
+\n\
+    v_color = color;\n\
+    v_color.a *= show;\n\
+\n\
+    gl_Position *= show;\n\
+}\n\
+";

package/Source/Shaders/BufferPolylineMaterialFS.glsl

@@ -0,0 +1,13 @@
+in vec4 v_pickColor;
+in vec4 v_color;
+
+void main()
+{
+    if (v_color.a < 0.005)   // matches 0/255 and 1/255
+    {
+        discard;
+    }
+
+    out_FragColor = czm_gammaCorrect(v_color);
+    czm_writeLogDepth();
+}

package/Source/Shaders/BufferPolylineMaterialFS.js

@@ -0,0 +1,15 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "in vec4 v_pickColor;\n\
+in vec4 v_color;\n\
+\n\
+void main()\n\
+{\n\
+    if (v_color.a < 0.005)   // matches 0/255 and 1/255\n\
+    {\n\
+        discard;\n\
+    }\n\
+\n\
+    out_FragColor = czm_gammaCorrect(v_color);\n\
+    czm_writeLogDepth();\n\
+}\n\
+";