@cesium/engine 26.0.0 → 26.2.0

package/Source/Scene/renderBufferPolylineCollection.js

@@ -84,9 +84,9 @@ const pickColor = new Color();
 const cartesian = new Cartesian3();
 const prevCartesian = new Cartesian3();
 const nextCartesian = new Cartesian3();
-const cartesianEnc = new EncodedCartesian3();
-const prevCartesianEnc = new EncodedCartesian3();
-const nextCartesianEnc = new EncodedCartesian3();
+const encodedC = new EncodedCartesian3();
+const encodedP = new EncodedCartesian3();
+const encodedN = new EncodedCartesian3();
 
 /**
  * Renders line segments as quads, each composed of two triangles. Writes each
@@ -167,13 +167,28 @@ function renderBufferPolylineCollection(collection, frameState, renderContext) {
 
   if (collection._dirtyCount > 0) {
     const { _dirtyOffset, _dirtyCount } = collection;
-    const { attributeArrays } = renderContext;
 
     const indexArray = renderContext.indexArray;
-    const pickColorArray = attributeArrays.pickColor;
-    const showColorWidthAndTexCoordArray =
-      attributeArrays.showColorWidthAndTexCoord;
-    const alphaArray = attributeArrays.alpha;
+
+    const {
+      // Common.
+      pickColor: pickColorArray,
+      showColorWidthAndTexCoord: showColorWidthAndTexCoordArray,
+      alpha: alphaArray,
+
+      // 8-32 bit.
+      position,
+      prevPosition,
+      nextPosition,
+
+      // 64 bit.
+      positionHigh,
+      positionLow,
+      prevPositionHigh,
+      prevPositionLow,
+      nextPositionHigh,
+      nextPositionLow,
+    } = renderContext.attributeArrays;
 
     for (let i = _dirtyOffset, il = _dirtyOffset + _dirtyCount; i < il; i++) {
       collection.get(i, polyline);
@@ -191,199 +206,112 @@ function renderBufferPolylineCollection(collection, frameState, renderContext) {
       let vOffset = polyline.vertexOffset * 2; // vertex offset
       let iOffset = (polyline.vertexOffset - i) * 6; // index offset
 
-      const jl = polyline.vertexCount;
-
-      if (!useFloat64) {
-        const posView = collection._positionView;
-        const posStart = polyline.vertexOffset * 3;
-        const posArray = attributeArrays.position;
-        const prevPosArray = attributeArrays.prevPosition;
-        const nextPosArray = attributeArrays.nextPosition;
-
-        for (let j = 0; j < jl; j++) {
-          const isFirstSegment = j === 0;
-          const isLastSegment = j === jl - 1;
-
-          const cx = posView[posStart + j * 3];
-          const cy = posView[posStart + j * 3 + 1];
-          const cz = posView[posStart + j * 3 + 2];
-
-          let px, py, pz, nx, ny, nz;
-
-          if (isFirstSegment) {
-            nx = posView[posStart + 1 * 3];
-            ny = posView[posStart + 1 * 3 + 1];
-            nz = posView[posStart + 1 * 3 + 2];
-            // Mirror current over next to get synthetic prev.
-            px = 2 * cx - nx;
-            py = 2 * cy - ny;
-            pz = 2 * cz - nz;
-          } else if (isLastSegment) {
-            px = posView[posStart + (j - 1) * 3];
-            py = posView[posStart + (j - 1) * 3 + 1];
-            pz = posView[posStart + (j - 1) * 3 + 2];
-            // Mirror current over prev to get synthetic next.
-            nx = 2 * cx - px;
-            ny = 2 * cy - py;
-            nz = 2 * cz - pz;
-          } else {
-            px = posView[posStart + (j - 1) * 3];
-            py = posView[posStart + (j - 1) * 3 + 1];
-            pz = posView[posStart + (j - 1) * 3 + 2];
-            nx = posView[posStart + (j + 1) * 3];
-            ny = posView[posStart + (j + 1) * 3 + 1];
-            nz = posView[posStart + (j + 1) * 3 + 2];
-          }
+      const posView = collection._positionView;
+      const posStart = polyline.vertexOffset * 3;
+
+      for (let j = 0, jl = polyline.vertexCount; j < jl; j++) {
+        const isFirstSegment = j === 0;
+        const isLastSegment = j === jl - 1;
+
+        // c=current, p=previous, n=next
+
+        const cx = posView[posStart + j * 3];
+        const cy = posView[posStart + j * 3 + 1];
+        const cz = posView[posStart + j * 3 + 2];
+
+        let px, py, pz, nx, ny, nz;
+
+        if (isFirstSegment) {
+          nx = posView[posStart + 1 * 3];
+          ny = posView[posStart + 1 * 3 + 1];
+          nz = posView[posStart + 1 * 3 + 2];
+          // Mirror current over next to get synthetic prev.
+          px = 2 * cx - nx;
+          py = 2 * cy - ny;
+          pz = 2 * cz - nz;
+        } else if (isLastSegment) {
+          px = posView[posStart + (j - 1) * 3];
+          py = posView[posStart + (j - 1) * 3 + 1];
+          pz = posView[posStart + (j - 1) * 3 + 2];
+          // Mirror current over prev to get synthetic next.
+          nx = 2 * cx - px;
+          ny = 2 * cy - py;
+          nz = 2 * cz - pz;
+        } else {
+          px = posView[posStart + (j - 1) * 3];
+          py = posView[posStart + (j - 1) * 3 + 1];
+          pz = posView[posStart + (j - 1) * 3 + 2];
+          nx = posView[posStart + (j + 1) * 3];
+          ny = posView[posStart + (j + 1) * 3 + 1];
+          nz = posView[posStart + (j + 1) * 3 + 2];
+        }
 
-          if (!isLastSegment) {
-            indexArray[iOffset] = vOffset;
-            indexArray[iOffset + 1] = vOffset + 1;
-            indexArray[iOffset + 2] = vOffset + 2;
-            indexArray[iOffset + 3] = vOffset + 2;
-            indexArray[iOffset + 4] = vOffset + 1;
-            indexArray[iOffset + 5] = vOffset + 3;
-            iOffset += 6;
-          }
+        if (!isLastSegment) {
+          indexArray[iOffset] = vOffset;
+          indexArray[iOffset + 1] = vOffset + 1;
+          indexArray[iOffset + 2] = vOffset + 2;
+          indexArray[iOffset + 3] = vOffset + 2;
+          indexArray[iOffset + 4] = vOffset + 1;
+          indexArray[iOffset + 5] = vOffset + 3;
+          iOffset += 6;
+        }
 
-          // Write each vertex twice for the quad.
-          for (let k = 0; k < 2; k++) {
-            posArray[vOffset * 3] = cx;
-            posArray[vOffset * 3 + 1] = cy;
-            posArray[vOffset * 3 + 2] = cz;
-
-            prevPosArray[vOffset * 3] = px;
-            prevPosArray[vOffset * 3 + 1] = py;
-            prevPosArray[vOffset * 3 + 2] = pz;
-
-            nextPosArray[vOffset * 3] = nx;
-            nextPosArray[vOffset * 3 + 1] = ny;
-            nextPosArray[vOffset * 3 + 2] = nz;
-
-            pickColorArray[vOffset * 4] = Color.floatToByte(pickColor.red);
-            pickColorArray[vOffset * 4 + 1] = Color.floatToByte(
-              pickColor.green,
-            );
-            pickColorArray[vOffset * 4 + 2] = Color.floatToByte(pickColor.blue);
-            pickColorArray[vOffset * 4 + 3] = Color.floatToByte(
-              pickColor.alpha,
-            );
-
-            showColorWidthAndTexCoordArray[vOffset * 4] = show ? 1 : 0;
-            showColorWidthAndTexCoordArray[vOffset * 4 + 1] = encodedColor;
-            showColorWidthAndTexCoordArray[vOffset * 4 + 2] = material.width;
-            showColorWidthAndTexCoordArray[vOffset * 4 + 3] = j / (jl - 1);
-
-            alphaArray[vOffset] = colorAlpha * 255.0;
-
-            vOffset++;
-          }
+        if (useFloat64) {
+          Cartesian3.fromElements(cx, cy, cz, cartesian);
+          Cartesian3.fromElements(px, py, pz, prevCartesian);
+          Cartesian3.fromElements(nx, ny, nz, nextCartesian);
+          EncodedCartesian3.fromCartesian(cartesian, encodedC);
+          EncodedCartesian3.fromCartesian(prevCartesian, encodedP);
+          EncodedCartesian3.fromCartesian(nextCartesian, encodedN);
         }
-      } else {
-        const cartesianArray = polyline.getPositions();
-
-        for (let j = 0; j < jl; j++) {
-          const isFirstSegment = j === 0;
-          const isLastSegment = j === jl - 1;
-
-          // For first/last vertices, infer missing vertices by mirroring the segment.
-          // @ts-expect-error TODO(tsd-jsdoc): See https://github.com/CesiumGS/cesium/pull/13302.
-          Cartesian3.fromArray(cartesianArray, j * 3, cartesian);
-          if (isFirstSegment) {
-            // @ts-expect-error TODO(tsd-jsdoc): See https://github.com/CesiumGS/cesium/pull/13302.
-            Cartesian3.fromArray(cartesianArray, (j + 1) * 3, nextCartesian);
-            Cartesian3.subtract(cartesian, nextCartesian, prevCartesian);
-            Cartesian3.add(cartesian, prevCartesian, prevCartesian);
-          } else if (isLastSegment) {
-            // @ts-expect-error TODO(tsd-jsdoc): See https://github.com/CesiumGS/cesium/pull/13302.
-            Cartesian3.fromArray(cartesianArray, (j - 1) * 3, prevCartesian);
-            Cartesian3.subtract(cartesian, prevCartesian, nextCartesian);
-            Cartesian3.add(cartesian, nextCartesian, nextCartesian);
+
+        // TODO(donmccurdy): Diverging from PolylineCollection.js, which writes
+        // internal vertices to buffer 4x, not 2x. Not sure that's needed?
+
+        // Write each vertex twice for the quad.
+        for (let k = 0; k < 2; k++) {
+          if (!useFloat64) {
+            position[vOffset * 3] = cx;
+            position[vOffset * 3 + 1] = cy;
+            position[vOffset * 3 + 2] = cz;
+
+            prevPosition[vOffset * 3] = px;
+            prevPosition[vOffset * 3 + 1] = py;
+            prevPosition[vOffset * 3 + 2] = pz;
+
+            nextPosition[vOffset * 3] = nx;
+            nextPosition[vOffset * 3 + 1] = ny;
+            nextPosition[vOffset * 3 + 2] = nz;
           } else {
-            // @ts-expect-error TODO(tsd-jsdoc): See https://github.com/CesiumGS/cesium/pull/13302.
-            Cartesian3.fromArray(cartesianArray, (j - 1) * 3, prevCartesian);
-            // @ts-expect-error TODO(tsd-jsdoc): See https://github.com/CesiumGS/cesium/pull/13302.
-            Cartesian3.fromArray(cartesianArray, (j + 1) * 3, nextCartesian);
+            // @ts-expect-error https://github.com/CesiumGS/cesium/pull/13302
+            Cartesian3.pack(encodedC.high, positionHigh, vOffset * 3);
+            // @ts-expect-error https://github.com/CesiumGS/cesium/pull/13302
+            Cartesian3.pack(encodedC.low, positionLow, vOffset * 3);
+
+            // @ts-expect-error https://github.com/CesiumGS/cesium/pull/13302
+            Cartesian3.pack(encodedP.high, prevPositionHigh, vOffset * 3);
+            // @ts-expect-error https://github.com/CesiumGS/cesium/pull/13302
+            Cartesian3.pack(encodedP.low, prevPositionLow, vOffset * 3);
+
+            // @ts-expect-error https://github.com/CesiumGS/cesium/pull/13302
+            Cartesian3.pack(encodedN.high, nextPositionHigh, vOffset * 3);
+            // @ts-expect-error https://github.com/CesiumGS/cesium/pull/13302
+            Cartesian3.pack(encodedN.low, nextPositionLow, vOffset * 3);
           }
 
-          // For each segment, draw two triangles.
-          if (!isLastSegment) {
-            indexArray[iOffset] = vOffset;
-            indexArray[iOffset + 1] = vOffset + 1;
-            indexArray[iOffset + 2] = vOffset + 2;
+          pickColorArray[vOffset * 4] = Color.floatToByte(pickColor.red);
+          pickColorArray[vOffset * 4 + 1] = Color.floatToByte(pickColor.green);
+          pickColorArray[vOffset * 4 + 2] = Color.floatToByte(pickColor.blue);
+          pickColorArray[vOffset * 4 + 3] = Color.floatToByte(pickColor.alpha);
 
-            indexArray[iOffset + 3] = vOffset + 2;
-            indexArray[iOffset + 4] = vOffset + 1;
-            indexArray[iOffset + 5] = vOffset + 3;
+          showColorWidthAndTexCoordArray[vOffset * 4] = show ? 1 : 0;
+          showColorWidthAndTexCoordArray[vOffset * 4 + 1] = encodedColor;
+          showColorWidthAndTexCoordArray[vOffset * 4 + 2] = material.width;
+          showColorWidthAndTexCoordArray[vOffset * 4 + 3] = j / (jl - 1);
 
-            iOffset += 6;
-          }
+          alphaArray[vOffset] = colorAlpha * 255.0;
 
-          EncodedCartesian3.fromCartesian(cartesian, cartesianEnc);
-          EncodedCartesian3.fromCartesian(prevCartesian, prevCartesianEnc);
-          EncodedCartesian3.fromCartesian(nextCartesian, nextCartesianEnc);
-
-          // TODO(donmccurdy): Diverging from PolylineCollection.js, which writes
-          // internal vertices to buffer 4x, not 2x. Not sure that's needed?
-          for (let k = 0; k < 2; k++) {
-            // Position.
-            attributeArrays.positionHigh[vOffset * 3] = cartesianEnc.high.x;
-            attributeArrays.positionHigh[vOffset * 3 + 1] = cartesianEnc.high.y;
-            attributeArrays.positionHigh[vOffset * 3 + 2] = cartesianEnc.high.z;
-
-            attributeArrays.positionLow[vOffset * 3] = cartesianEnc.low.x;
-            attributeArrays.positionLow[vOffset * 3 + 1] = cartesianEnc.low.y;
-            attributeArrays.positionLow[vOffset * 3 + 2] = cartesianEnc.low.z;
-
-            // Previous position.
-            attributeArrays.prevPositionHigh[vOffset * 3] =
-              prevCartesianEnc.high.x;
-            attributeArrays.prevPositionHigh[vOffset * 3 + 1] =
-              prevCartesianEnc.high.y;
-            attributeArrays.prevPositionHigh[vOffset * 3 + 2] =
-              prevCartesianEnc.high.z;
-
-            attributeArrays.prevPositionLow[vOffset * 3] =
-              prevCartesianEnc.low.x;
-            attributeArrays.prevPositionLow[vOffset * 3 + 1] =
-              prevCartesianEnc.low.y;
-            attributeArrays.prevPositionLow[vOffset * 3 + 2] =
-              prevCartesianEnc.low.z;
-
-            // Next position.
-            attributeArrays.nextPositionHigh[vOffset * 3] =
-              nextCartesianEnc.high.x;
-            attributeArrays.nextPositionHigh[vOffset * 3 + 1] =
-              nextCartesianEnc.high.y;
-            attributeArrays.nextPositionHigh[vOffset * 3 + 2] =
-              nextCartesianEnc.high.z;
-
-            attributeArrays.nextPositionLow[vOffset * 3] =
-              nextCartesianEnc.low.x;
-            attributeArrays.nextPositionLow[vOffset * 3 + 1] =
-              nextCartesianEnc.low.y;
-            attributeArrays.nextPositionLow[vOffset * 3 + 2] =
-              nextCartesianEnc.low.z;
-
-            // Pick ID.
-            pickColorArray[vOffset * 4] = Color.floatToByte(pickColor.red);
-            pickColorArray[vOffset * 4 + 1] = Color.floatToByte(
-              pickColor.green,
-            );
-            pickColorArray[vOffset * 4 + 2] = Color.floatToByte(pickColor.blue);
-            pickColorArray[vOffset * 4 + 3] = Color.floatToByte(
-              pickColor.alpha,
-            );
-
-            // Properties.
-            showColorWidthAndTexCoordArray[vOffset * 4] = show ? 1 : 0;
-            showColorWidthAndTexCoordArray[vOffset * 4 + 1] = encodedColor;
-            showColorWidthAndTexCoordArray[vOffset * 4 + 2] = material.width;
-            showColorWidthAndTexCoordArray[vOffset * 4 + 3] = j / (jl - 1); // texcoord.s
-
-            alphaArray[vOffset] = colorAlpha * 255.0;
-
-            vOffset++;
-          }
+          vOffset++;
         }
       }
 
@@ -616,8 +544,7 @@ function renderBufferPolylineCollection(collection, frameState, renderContext) {
 
   frameState.commandList.push(command);
 
-  collection._dirtyCount = 0;
-  collection._dirtyOffset = 0;
+  collection._makeClean();
 
   return renderContext;
 }

package/Source/Shaders/Builtin/Constants/passCesium3DTile.glsl

@@ -6,4 +6,4 @@
  *
  * @see czm_pass
  */
-const float czm_passCesium3DTile = 5.0;
+const float czm_passCesium3DTile = 6.0;

package/Source/Shaders/Builtin/Constants/passCesium3DTile.js

@@ -7,5 +7,5 @@ export default "/**\n\
  *\n\
  * @see czm_pass\n\
  */\n\
-const float czm_passCesium3DTile = 5.0;\n\
+const float czm_passCesium3DTile = 6.0;\n\
 ";

package/Source/Shaders/Builtin/Constants/passCesium3DTileClassification.glsl

@@ -6,4 +6,4 @@
  *
  * @see czm_pass
  */
-const float czm_passCesium3DTileClassification = 6.0;
+const float czm_passCesium3DTileClassification = 7.0;

package/Source/Shaders/Builtin/Constants/passCesium3DTileClassification.js

@@ -7,5 +7,5 @@ export default "/**\n\
  *\n\
  * @see czm_pass\n\
  */\n\
-const float czm_passCesium3DTileClassification = 6.0;\n\
+const float czm_passCesium3DTileClassification = 7.0;\n\
 ";

package/Source/Shaders/Builtin/Constants/passCesium3DTileClassificationIgnoreShow.glsl

@@ -6,4 +6,4 @@
  *
  * @see czm_pass
  */
-const float czm_passCesium3DTileClassificationIgnoreShow = 7.0;
+const float czm_passCesium3DTileClassificationIgnoreShow = 8.0;

package/Source/Shaders/Builtin/Constants/passCesium3DTileClassificationIgnoreShow.js

@@ -7,5 +7,5 @@ export default "/**\n\
  *\n\
  * @see czm_pass\n\
  */\n\
-const float czm_passCesium3DTileClassificationIgnoreShow = 7.0;\n\
+const float czm_passCesium3DTileClassificationIgnoreShow = 8.0;\n\
 ";

package/Source/Shaders/Builtin/Constants/passCesium3DTilePlanarFillId.glsl

@@ -0,0 +1,9 @@
+/**
+ * The automatic GLSL constant for {@link Pass#CESIUM_3D_TILE_PLANAR_FILL_ID}
+ *
+ * @name czm_passCesium3DTilePlanarFillId
+ * @glslConstant
+ *
+ * @see czm_pass
+ */
+const float czm_passCesium3DTilePlanarFillId = 5.0;

package/Source/Shaders/Builtin/Constants/passCesium3DTilePlanarFillId.js

@@ -0,0 +1,11 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "/**\n\
+ * The automatic GLSL constant for {@link Pass#CESIUM_3D_TILE_PLANAR_FILL_ID}\n\
+ *\n\
+ * @name czm_passCesium3DTilePlanarFillId\n\
+ * @glslConstant\n\
+ *\n\
+ * @see czm_pass\n\
+ */\n\
+const float czm_passCesium3DTilePlanarFillId = 5.0;\n\
+";

package/Source/Shaders/Builtin/Constants/passClassification.glsl

@@ -6,4 +6,4 @@
  *
  * @see czm_pass
  */
-const float czm_passClassification = 7.0;
+const float czm_passClassification = 8.0;

package/Source/Shaders/Builtin/Constants/passClassification.js

@@ -7,5 +7,5 @@ export default "/**\n\
  *\n\
  * @see czm_pass\n\
  */\n\
-const float czm_passClassification = 7.0;\n\
+const float czm_passClassification = 8.0;\n\
 ";

package/Source/Shaders/Builtin/Constants/passGaussianSplats.glsl

@@ -6,4 +6,4 @@
  *
  * @see czm_pass
  */
-const float czm_passGaussianSplats = 11.0;
+const float czm_passGaussianSplats = 12.0;

package/Source/Shaders/Builtin/Constants/passGaussianSplats.js

@@ -7,5 +7,5 @@ export default "/**\n\
  *\n\
  * @see czm_pass\n\
  */\n\
-const float czm_passGaussianSplats = 11.0;\n\
+const float czm_passGaussianSplats = 12.0;\n\
 ";

package/Source/Shaders/Builtin/Constants/passOpaque.glsl

@@ -6,4 +6,4 @@
  *
  * @see czm_pass
  */
-const float czm_passOpaque = 8.0;
+const float czm_passOpaque = 9.0;

package/Source/Shaders/Builtin/Constants/passOpaque.js

@@ -7,5 +7,5 @@ export default "/**\n\
  *\n\
  * @see czm_pass\n\
  */\n\
-const float czm_passOpaque = 8.0;\n\
+const float czm_passOpaque = 9.0;\n\
 ";

package/Source/Shaders/Builtin/Constants/passTranslucent.glsl

@@ -6,4 +6,4 @@
  *
  * @see czm_pass
  */
-const float czm_passTranslucent = 9.0;
+const float czm_passTranslucent = 10.0;

package/Source/Shaders/Builtin/Constants/passTranslucent.js

@@ -7,5 +7,5 @@ export default "/**\n\
  *\n\
  * @see czm_pass\n\
  */\n\
-const float czm_passTranslucent = 9.0;\n\
+const float czm_passTranslucent = 10.0;\n\
 ";

package/Source/Shaders/Builtin/Constants/passVoxels.glsl

@@ -6,4 +6,4 @@
  *
  * @see czm_pass
  */
-const float czm_passVoxels = 10.0;
+const float czm_passVoxels = 11.0;

package/Source/Shaders/Builtin/Constants/passVoxels.js

@@ -7,5 +7,5 @@ export default "/**\n\
  *\n\
  * @see czm_pass\n\
  */\n\
-const float czm_passVoxels = 10.0;\n\
+const float czm_passVoxels = 11.0;\n\
 ";

package/Source/Shaders/Builtin/CzmBuiltins.js

@@ -16,6 +16,7 @@ import czm_passCesium3DTileClassification from './Constants/passCesium3DTileClas
 import czm_passCesium3DTileClassificationIgnoreShow from './Constants/passCesium3DTileClassificationIgnoreShow.js'
 import czm_passCesium3DTileEdges from './Constants/passCesium3DTileEdges.js'
 import czm_passCesium3DTileEdgesDirect from './Constants/passCesium3DTileEdgesDirect.js'
+import czm_passCesium3DTilePlanarFillId from './Constants/passCesium3DTilePlanarFillId.js'
 import czm_passClassification from './Constants/passClassification.js'
 import czm_passCompute from './Constants/passCompute.js'
 import czm_passEnvironment from './Constants/passEnvironment.js'
@@ -160,6 +161,7 @@ export default {
     czm_passCesium3DTileClassificationIgnoreShow : czm_passCesium3DTileClassificationIgnoreShow,
     czm_passCesium3DTileEdges : czm_passCesium3DTileEdges,
     czm_passCesium3DTileEdgesDirect : czm_passCesium3DTileEdgesDirect,
+    czm_passCesium3DTilePlanarFillId : czm_passCesium3DTilePlanarFillId,
     czm_passClassification : czm_passClassification,
     czm_passCompute : czm_passCompute,
     czm_passEnvironment : czm_passEnvironment,

package/Source/Shaders/GlobeFS.glsl

@@ -88,7 +88,7 @@ uniform float u_minimumBrightness;
 #endif
 
 // Based on colorCorrect
-// The colorCorrect flag can only be true when tileProvider.hue/saturation/brightnessShift 
+// The colorCorrect flag can only be true when tileProvider.hue/saturation/brightnessShift
 // are nonzero AND when (applyFog || showGroundAtmosphere) in the tile provider
 // - The tileProvider.hue/saturation/brightnessShift are just passed through
 //   from the Globe hue/saturation/brightness, like atmosphereBrightnessShift
@@ -116,8 +116,8 @@ uniform vec4 u_translucencyRectangle;
 #endif
 
 // Based on showUndergroundColor
-// This is set when GlobeSurfaceTileProvider.isUndergroundVisible 
-// returns true, AND the tileProvider.undergroundColor had a value with 
+// This is set when GlobeSurfaceTileProvider.isUndergroundVisible
+// returns true, AND the tileProvider.undergroundColor had a value with
 // nonzero alpha, and the tileProvider.undergroundColorAlphaByDistance
 // was in the right range
 #ifdef UNDERGROUND_COLOR
@@ -576,11 +576,16 @@ void main()
     }
 #endif
 
+#ifdef HAS_VECTOR_LAYER
+    finalColor = vectorPolygonRender(v_textureCoordinates.xy, finalColor);
+    finalColor = vectorPolylineRender(v_textureCoordinates.xy, finalColor);
+#endif
+
 #ifdef TRANSLUCENT
     if (inTranslucencyRectangle())
     {
-      vec4 alphaByDistance = gl_FrontFacing ? u_frontFaceAlphaByDistance : u_backFaceAlphaByDistance;
-      finalColor.a *= interpolateByDistance(alphaByDistance, v_distance);
+        vec4 alphaByDistance = gl_FrontFacing ? u_frontFaceAlphaByDistance : u_backFaceAlphaByDistance;
+        finalColor.a *= interpolateByDistance(alphaByDistance, v_distance);
     }
 #endif
 

package/Source/Shaders/GlobeFS.js

@@ -89,7 +89,7 @@ uniform float u_minimumBrightness;\n\
 #endif\n\
 \n\
 // Based on colorCorrect\n\
-// The colorCorrect flag can only be true when tileProvider.hue/saturation/brightnessShift \n\
+// The colorCorrect flag can only be true when tileProvider.hue/saturation/brightnessShift\n\
 // are nonzero AND when (applyFog || showGroundAtmosphere) in the tile provider\n\
 // - The tileProvider.hue/saturation/brightnessShift are just passed through\n\
 //   from the Globe hue/saturation/brightness, like atmosphereBrightnessShift\n\
@@ -117,8 +117,8 @@ uniform vec4 u_translucencyRectangle;\n\
 #endif\n\
 \n\
 // Based on showUndergroundColor\n\
-// This is set when GlobeSurfaceTileProvider.isUndergroundVisible \n\
-// returns true, AND the tileProvider.undergroundColor had a value with \n\
+// This is set when GlobeSurfaceTileProvider.isUndergroundVisible\n\
+// returns true, AND the tileProvider.undergroundColor had a value with\n\
 // nonzero alpha, and the tileProvider.undergroundColorAlphaByDistance\n\
 // was in the right range\n\
 #ifdef UNDERGROUND_COLOR\n\
@@ -577,11 +577,15 @@ void main()\n\
     }\n\
 #endif\n\
 \n\
+#ifdef HAS_VECTOR_LAYER\n\
+    finalColor = vectorPolylineRender(v_textureCoordinates.xy, finalColor);\n\
+#endif\n\
+\n\
 #ifdef TRANSLUCENT\n\
     if (inTranslucencyRectangle())\n\
     {\n\
-      vec4 alphaByDistance = gl_FrontFacing ? u_frontFaceAlphaByDistance : u_backFaceAlphaByDistance;\n\
-      finalColor.a *= interpolateByDistance(alphaByDistance, v_distance);\n\
+        vec4 alphaByDistance = gl_FrontFacing ? u_frontFaceAlphaByDistance : u_backFaceAlphaByDistance;\n\
+        finalColor.a *= interpolateByDistance(alphaByDistance, v_distance);\n\
     }\n\
 #endif\n\
 \n\

package/Source/Shaders/Materials/PolylineGlowMaterial.glsl

@@ -15,7 +15,7 @@ czm_material czm_getMaterial(czm_materialInput materialInput)
 
     vec4 fragColor;
     fragColor.rgb = max(vec3(glow - 1.0 + color.rgb), color.rgb);
-    fragColor.a = clamp(0.0, 1.0, glow) * color.a;
+    fragColor.a = clamp(glow, 0.0, 1.0) * color.a;
     fragColor = czm_gammaCorrect(fragColor);
 
     material.emission = fragColor.rgb;

package/Source/Shaders/Materials/PolylineGlowMaterial.js

@@ -16,7 +16,7 @@ czm_material czm_getMaterial(czm_materialInput materialInput)\n\
 \n\
     vec4 fragColor;\n\
     fragColor.rgb = max(vec3(glow - 1.0 + color.rgb), color.rgb);\n\
-    fragColor.a = clamp(0.0, 1.0, glow) * color.a;\n\
+    fragColor.a = clamp(glow, 0.0, 1.0) * color.a;\n\
     fragColor = czm_gammaCorrect(fragColor);\n\
 \n\
     material.emission = fragColor.rgb;\n\

package/Source/Shaders/Model/MaterialStageFS.glsl

@@ -463,8 +463,14 @@ void materialStage(inout czm_modelMaterial material, ProcessedAttributes attribu
     #endif
 
     vec4 baseColorWithAlpha = vec4(1.0);
-    // Regardless of whether we use PBR, set a base color
-    #ifdef HAS_BASE_COLOR_TEXTURE
+    // Regardless of whether we use PBR, set a base color.
+    // HAS_BACKGROUND_FILL (from BENTLEY_materials_planar_fill) overrides with
+    // the view's background color to create an invisible masking polygon.
+    // The background color is in sRGB, so convert to linear to match the
+    // material pipeline's expected color space.
+    #ifdef HAS_BACKGROUND_FILL
+        baseColorWithAlpha = czm_srgbToLinear(czm_backgroundColor);
+    #elif defined(HAS_BASE_COLOR_TEXTURE)
         baseColorWithAlpha = getBaseColorFromTexture();
     #elif defined(HAS_BASE_COLOR_FACTOR)
         baseColorWithAlpha = u_baseColorFactor;