@cesium/engine 26.2.0 → 26.3.0

package/Source/Scene/Model/ModelVectorLookupPipelineStage.js

@@ -0,0 +1,205 @@
+// @ts-check
+
+import Cartesian2 from "../../Core/Cartesian2.js";
+import combine from "../../Core/combine.js";
+import CesiumMath from "../../Core/Math.js";
+import ShaderDestination from "../../Renderer/ShaderDestination.js";
+import VectorCommon from "../../Shaders/VectorCommon.js";
+import ModelVectorLookupStageVS from "../../Shaders/Model/ModelVectorLookupStageVS.js";
+import ModelVectorLookupStageFS from "../../Shaders/Model/ModelVectorLookupStageFS.js";
+
+/** @import FrameState from "../FrameState.js"; */
+/** @import Model from "./Model.js"; */
+/** @import ModelRenderResources from "./ModelRenderResources.js"; */
+
+/**
+ * The model vector lookup stage drapes vector data, baked into
+ * per-content lookup textures by the scene's VectorProvider, onto the model's
+ * surface.
+ *
+ * @namespace ModelVectorLookupPipelineStage
+ *
+ * @private
+ */
+const ModelVectorLookupPipelineStage = {
+  name: "ModelVectorLookupPipelineStage", // Helps with debugging
+  process: process,
+};
+
+const scratchCameraUv = new Cartesian2();
+const scratchRectangleInverseSize = new Cartesian2();
+
+/**
+ * Processes a model with baked vector lookup data. This modifies the
+ * following parts of the render resources:
+ *
+ * <ul>
+ *  <li>adds the HAS_VECTOR_LOOKUP define to both shaders</li>
+ *  <li>adds a vertex shader function computing the vertex's UV within the baked rectangle</li>
+ *  <li>adds the shared vector lookup functions and a compositing function to the fragment shader</li>
+ *  <li>adds the uniforms for the baked rectangle and the lookup textures</li>
+ * </ul>
+ *
+ * @param {ModelRenderResources} renderResources The render resources for this model.
+ * @param {Model} model The model.
+ * @param {FrameState} frameState The frameState.
+ *
+ * @private
+ */
+function process(renderResources, model, frameState) {
+  const shaderBuilder = renderResources.shaderBuilder;
+  const vectorData = model._vectorData;
+  const hasPolylines = vectorData.hasPolylines;
+  const hasPolygons = vectorData.hasPolygons;
+
+  shaderBuilder.addDefine(
+    "HAS_VECTOR_LOOKUP",
+    undefined,
+    ShaderDestination.BOTH,
+  );
+
+  if (hasPolylines) {
+    shaderBuilder.addDefine(
+      "HAS_VECTOR_POLYLINES",
+      undefined,
+      ShaderDestination.FRAGMENT,
+    );
+
+    if (vectorData.hasMeterWidths) {
+      shaderBuilder.addDefine(
+        "VECTOR_WIDTH_IN_METERS",
+        undefined,
+        ShaderDestination.FRAGMENT,
+      );
+      if (vectorData.hasPixelWidths) {
+        shaderBuilder.addDefine(
+          "VECTOR_WIDTH_MIXED_UNITS",
+          undefined,
+          ShaderDestination.FRAGMENT,
+        );
+      }
+      shaderBuilder.addUniform(
+        "vec2",
+        "u_vectorMetersPerUv",
+        ShaderDestination.FRAGMENT,
+      );
+    }
+  }
+
+  if (hasPolygons) {
+    shaderBuilder.addDefine(
+      "HAS_VECTOR_POLYGONS",
+      undefined,
+      ShaderDestination.FRAGMENT,
+    );
+  }
+
+  shaderBuilder.addUniform(
+    "vec2",
+    "u_vectorCameraUv",
+    ShaderDestination.VERTEX,
+  );
+  shaderBuilder.addUniform(
+    "vec2",
+    "u_vectorRectangleInverseSize",
+    ShaderDestination.VERTEX,
+  );
+
+  shaderBuilder.addVarying("vec2", "v_vectorUv");
+  shaderBuilder.addVertexLines(ModelVectorLookupStageVS);
+  // VectorCommon declares the lookup texture uniforms and sampling functions
+  // shared with the terrain path.
+  shaderBuilder.addFragmentLines(VectorCommon);
+  shaderBuilder.addFragmentLines(ModelVectorLookupStageFS);
+
+  // A re-bake replaces _vectorData, and its rectangle, without rebuilding draw
+  // commands, so the callbacks read the rectangle per call.
+  const buildRectangle = vectorData.rectangle;
+
+  const defaultTexture = function () {
+    return frameState.context.defaultTexture;
+  };
+
+  /** @type {Object<string, Function>} */
+  const uniformMap = {
+    // The UV coordinates of the camera within the baked rectangle.
+    u_vectorCameraUv: function () {
+      const rectangle = model._vectorData?.rectangle ?? buildRectangle;
+      const carto = frameState.camera.positionCartographic;
+
+      const halfWidth = rectangle.width * 0.5;
+      const centerLongitude = rectangle.west + halfWidth;
+      const longitudeOffset =
+        CesiumMath.negativePiToPi(carto.longitude - centerLongitude) +
+        halfWidth;
+      return Cartesian2.fromElements(
+        longitudeOffset / rectangle.width,
+        (carto.latitude - rectangle.south) / rectangle.height,
+        scratchCameraUv,
+      );
+    },
+    u_vectorRectangleInverseSize: function () {
+      const rectangle = model._vectorData?.rectangle ?? buildRectangle;
+      return Cartesian2.fromElements(
+        1.0 / rectangle.width,
+        1.0 / rectangle.height,
+        scratchRectangleInverseSize,
+      );
+    },
+    u_vectorColorTexture: function () {
+      return model._vectorData?.colorTexture ?? defaultTexture();
+    },
+    u_vectorPickColorTexture: function () {
+      return model._vectorData?.pickColorTexture ?? defaultTexture();
+    },
+  };
+
+  if (hasPolylines) {
+    uniformMap.u_vectorSegmentTexture = function () {
+      return model._vectorData?.polylineSegmentTexture ?? defaultTexture();
+    };
+    uniformMap.u_vectorWidthTexture = function () {
+      return model._vectorData?.widthTexture ?? defaultTexture();
+    };
+    uniformMap.u_vectorSegmentPrimitiveIndicesTexture = function () {
+      return (
+        model._vectorData?.polylineSegmentPrimitiveIndicesTexture ??
+        defaultTexture()
+      );
+    };
+    uniformMap.u_vectorGridCellIndicesTexture = function () {
+      return (
+        model._vectorData?.polylineGridCellIndicesTexture ?? defaultTexture()
+      );
+    };
+
+    if (vectorData.hasMeterWidths) {
+      uniformMap.u_vectorMetersPerUv = function () {
+        return model._vectorData.metersPerUv;
+      };
+    }
+  }
+
+  if (hasPolygons) {
+    uniformMap.u_vectorPolygonEdgeTexture = function () {
+      return model._vectorData?.polygonEdgeTexture ?? defaultTexture();
+    };
+    uniformMap.u_vectorPolygonEdgePrimitiveIndicesTexture = function () {
+      return (
+        model._vectorData?.polygonEdgePrimitiveIndicesTexture ??
+        defaultTexture()
+      );
+    };
+    uniformMap.u_vectorPolygonGridCellIndicesTexture = function () {
+      return (
+        model._vectorData?.polygonGridCellIndicesTexture ?? defaultTexture()
+      );
+    };
+  }
+
+  renderResources.uniformMap = /** @type {Object<string, Function>} */ (
+    combine(uniformMap, renderResources.uniformMap)
+  );
+}
+
+export default ModelVectorLookupPipelineStage;

package/Source/Scene/Model/PickingPipelineStage.js

@@ -93,6 +93,10 @@ PickingPipelineStage.process = function (
     renderResources.pickId = "czm_pickColor";
     renderResources.snapId = snapIdFromPickId(renderResources.pickId);
   }
+
+  if (!defined(model.classificationType) && model.hasDrapedVectors()) {
+    renderResources.pickId = `vectorPickColorOver(${renderResources.pickId})`;
+  }
 };
 
 /**

package/Source/Scene/PostProcessStage.js

@@ -7,8 +7,10 @@ import Frozen from "../Core/Frozen.js";
 import defined from "../Core/defined.js";
 import destroyObject from "../Core/destroyObject.js";
 import DeveloperError from "../Core/DeveloperError.js";
+import oneTimeWarning from "../Core/oneTimeWarning.js";
 import PixelFormat from "../Core/PixelFormat.js";
 import Resource from "../Core/Resource.js";
+import ContextLimits from "../Renderer/ContextLimits.js";
 import PassState from "../Renderer/PassState.js";
 import PixelDatatype from "../Renderer/PixelDatatype.js";
 import RenderState from "../Renderer/RenderState.js";
@@ -796,6 +798,19 @@ function createSelectedTexture(stage, context) {
     }
   }
 
+  // The selected ids are stored in a texture that is one texel per id, so the
+  // number of ids cannot exceed the maximum texture width supported by the
+  // hardware. Clamp instead of throwing so that a very large selection
+  // degrades gracefully (ids beyond the limit are not highlighted).
+  const maximumTextureSize = ContextLimits.maximumTextureSize;
+  if (textureLength > maximumTextureSize) {
+    PostProcessStage._oneTimeWarning(
+      "postProcessStageSelectedTextureSize",
+      `The number of selected feature ids (${textureLength}) exceeds the maximum texture size (${maximumTextureSize}). Features beyond the limit will not have the post-process effect applied.`,
+    );
+    textureLength = maximumTextureSize;
+  }
+
   if (features.length === 0 || textureLength === 0) {
     // max pick id is reserved
     const empty = new Uint8Array([255, 255, 255, 255]);
@@ -814,13 +829,14 @@ function createSelectedTexture(stage, context) {
   }
 
   let offset = 0;
-  const ids = new Uint8Array(textureLength * 4);
-  for (let i = 0; i < features.length; ++i) {
+  const idByteLength = textureLength * 4;
+  const ids = new Uint8Array(idByteLength);
+  for (let i = 0; i < features.length && offset < idByteLength; ++i) {
     const feature = features[i];
     if (defined(feature.pickIds)) {
       const pickIds = feature.pickIds;
       const pickIdsLength = pickIds.length;
-      for (let j = 0; j < pickIdsLength; ++j) {
+      for (let j = 0; j < pickIdsLength && offset < idByteLength; ++j) {
         const pickColor = pickIds[j].color;
         ids[offset] = Color.floatToByte(pickColor.red);
         ids[offset + 1] = Color.floatToByte(pickColor.green);
@@ -999,4 +1015,7 @@ PostProcessStage.prototype.destroy = function () {
   releaseResources(this);
   return destroyObject(this);
 };
+
+// Exposed for testing
+PostProcessStage._oneTimeWarning = oneTimeWarning;
 export default PostProcessStage;

package/Source/Scene/Scene.js

@@ -19,7 +19,7 @@ import Event from "../Core/Event.js";
 import GeographicProjection from "../Core/GeographicProjection.js";
 import GeometryInstance from "../Core/GeometryInstance.js";
 import GeometryPipeline from "../Core/GeometryPipeline.js";
-import HeightReference from "./HeightReference.js";
+import HeightReference, { isHeightReferenceClamp } from "./HeightReference.js";
 import Intersect from "../Core/Intersect.js";
 import JulianDate from "../Core/JulianDate.js";
 import CesiumMath from "../Core/Math.js";
@@ -34,6 +34,7 @@ import Rectangle from "../Core/Rectangle.js";
 import RequestScheduler from "../Core/RequestScheduler.js";
 import TaskProcessor from "../Core/TaskProcessor.js";
 import Transforms from "../Core/Transforms.js";
+import VectorProvider from "../Core/VectorProvider.js";
 import ClearCommand from "../Renderer/ClearCommand.js";
 import ComputeEngine from "../Renderer/ComputeEngine.js";
 import Context from "../Renderer/Context.js";
@@ -84,6 +85,7 @@ import getMetadataClassProperty from "./getMetadataClassProperty.js";
 import PickedMetadataInfo from "./PickedMetadataInfo.js";
 import getMetadataProperty from "./getMetadataProperty.js";
 
+/** @ignore */
 const requestRenderAfterFrame = function (scene) {
   return function () {
     scene.frameState.afterRender.push(function () {
@@ -3659,6 +3661,56 @@ function executeCommandsInViewport(firstViewport, scene, passState) {
 
 const scratchCullingVolume = new CullingVolume();
 
+/**
+ * Marks every drapeable collection in the subtree so the vector provider bakes it this frame
+ *
+ * @param {PrimitiveCollection} collection
+ * @param {VectorProvider} vectorProvider
+ * @param {number} frameNumber
+ * @private
+ */
+function markVectorCollections(collection, vectorProvider, frameNumber) {
+  if (!collection.show) {
+    return;
+  }
+
+  const length = collection.length;
+  for (let i = 0; i < length; ++i) {
+    const primitive = collection.get(i);
+    if (primitive instanceof PrimitiveCollection) {
+      markVectorCollections(primitive, vectorProvider, frameNumber);
+      continue;
+    }
+
+    if (
+      primitive.show &&
+      VectorProvider.isSupported(primitive) &&
+      isHeightReferenceClamp(primitive.heightReference)
+    ) {
+      vectorProvider.markForFrame(
+        primitive,
+        frameNumber,
+        primitive.heightReference,
+      );
+    }
+  }
+}
+
+/**
+ * @param {Scene} scene
+ * @param {FrameState} frameState
+ * @private
+ */
+function updateVectorProvider(scene, frameState) {
+  const vectorProvider = scene.vectorProvider;
+  if (!defined(vectorProvider)) {
+    return;
+  }
+
+  const frameNumber = frameState.frameNumber;
+  markVectorCollections(scene._primitives, vectorProvider, frameNumber);
+}
+
 /**
  * @private
  */
@@ -3793,6 +3845,8 @@ Scene.prototype.updateEnvironment = function () {
   if (defined(this._specularEnvironmentCubeMap)) {
     this._specularEnvironmentCubeMap.update(frameState);
   }
+
+  updateVectorProvider(this, frameState);
 };
 
 function updateDebugFrustumPlanes(scene) {
@@ -4724,6 +4778,7 @@ Scene.prototype.pick = function (windowPosition, width, height) {
  * @typedef {object} SceneSnapResult
  * @property {object} object The snapped primitive or feature.
  * @property {Cartesian3} position The world-space position of the snap point, un-projected from the snap framebuffer's eye-space depth.
+ * @property {Cartesian3|undefined} surfacePosition The world-space position of the same object's surface fragment nearest the snap point. For a surface snap this equals <code>position</code>; for an edge snap it is a point on a face of the object rather than on its silhouette, or <code>undefined</code> if no surface fragment of the object is visible in the search region.
  * @property {Cartesian2} screenPosition The window coordinates of the snap point.
  * @property {boolean} isEdge <code>true</code> if the snap point lies on an edge; <code>false</code> if it lies on a surface.
  *

package/Source/Scene/Snapping.js

@@ -35,6 +35,7 @@ const Snapping = {};
 
 const scratchRectangle = new BoundingRectangle(0.0, 0.0, 3.0, 3.0);
 const scratchSnapCoord = new Cartesian2();
+const scratchSurfaceCoord = new Cartesian2();
 const scratchSnapRay = new Ray();
 const scratchSnapOffset = new Cartesian3();
 
@@ -48,6 +49,13 @@ const SNAP_OCCLUDER_RADIUS_PIXELS = 3.0;
 // object the cursor is on.
 const SNAP_OCCLUSION_TOLERANCE = 0.1;
 
+// Width of the region, centered on a winning edge hit, read to find the
+// adjacent surface fragment for surfacePosition. Deliberately centered on the
+// edge hit rather than the cursor: the cursor-centered snap region can clip
+// away the object's surface, potentially causing the server-side backend to
+// give a mismatched snap.
+const SNAP_SURFACE_REGION_WIDTH = 9.0;
+
 function cursorDist(hit) {
   return Math.sqrt(hit.x * hit.x + hit.y * hit.y);
 }
@@ -76,6 +84,25 @@ function selectBestHit(hits) {
   );
 }
 
+// Find the surface hit belonging to the same object that lies closest to the
+// region center, if any. Unlike an edge hit, whose position lies exactly on
+// the object's silhouette, this point is unambiguously on the object.
+function nearestSurfaceHit(hits, object) {
+  let best;
+  let bestDist = Number.POSITIVE_INFINITY;
+  for (const hit of hits) {
+    if (hit.isEdge || hit.object !== object) {
+      continue;
+    }
+    const dist = hit.x * hit.x + hit.y * hit.y;
+    if (dist < bestDist) {
+      best = hit;
+      bestDist = dist;
+    }
+  }
+  return best;
+}
+
 // Unproject a snap hit's eye-space depth (channel B of the snap framebuffer,
 // written by the snap shader at the edge fragment itself) into a world
 // position.
@@ -166,10 +193,39 @@ Snapping.snap = function (scene, windowPosition, options) {
     return undefined;
   }
 
+  // For edge hits, also unproject the nearest same-object surface fragment so
+  // consumers have a seed point that is on the object but off its silhouette.
+  // Found with a read centered on the edge hit itself, so the seed does not
+  // depend on where in the snap region the cursor was.
+  let surfacePosition = position;
+  if (best.isEdge) {
+    const surfaceOrigin = scratchSurfaceCoord;
+    surfaceOrigin.x = windowPosition.x + best.x;
+    surfaceOrigin.y = windowPosition.y + best.y;
+    pickBegin(
+      scene,
+      surfaceOrigin,
+      drawingBufferRectangle,
+      SNAP_SURFACE_REGION_WIDTH,
+      SNAP_SURFACE_REGION_WIDTH,
+      {
+        framebuffer: snapFramebuffer,
+        snap: true,
+      },
+    );
+    const surfaceHits = snapFramebuffer.end(drawingBufferRectangle);
+    pickEnd(scene);
+    const surfaceHit = nearestSurfaceHit(surfaceHits, best.object);
+    surfacePosition = defined(surfaceHit)
+      ? snapHitToWorld(scene, surfaceOrigin, surfaceHit)
+      : undefined;
+  }
+
   return {
     object: best.object,
     isEdge: best.isEdge,
     position: position,
+    surfacePosition: surfacePosition,
     screenPosition: new Cartesian2(
       windowPosition.x + best.x,
       windowPosition.y + best.y,
@@ -179,6 +235,7 @@ Snapping.snap = function (scene, windowPosition, options) {
 
 // Exposed for testing.
 Snapping._selectBestHit = selectBestHit;
+Snapping._nearestSurfaceHit = nearestSurfaceHit;
 Snapping._snapHitToWorld = snapHitToWorld;
 
 export default Snapping;

package/Source/Scene/UrlTemplate3DTilesDataProvider.js

@@ -13,7 +13,9 @@ import destroyObject from "../Core/destroyObject.js";
 import CesiumMath from "../Core/Math.js";
 
 /** @import FrameState from "./FrameState.js"; */
+/** @import HeightReference from "./HeightReference.js"; */
 /** @import PassState from "../Renderer/PassState.js"; */
+/** @import Scene from "./Scene.js"; */
 /** @import TilingScheme from "../Core/TilingScheme.js"; */
 
 /**
@@ -51,6 +53,10 @@ class UrlTemplate3DTilesDataProvider {
    * @param {number} [options.maxZoom=14] Maximum zoom level represented in the generated tileset.
    * @param {Rectangle} [options.extent] Optional geographic extent in radians to constrain the generated tile tree.
    * @param {string} [options.featureIdProperty] Feature property name to use as feature ID when supported by content decoding.
+   * @param {HeightReference} [options.heightReference] Drapes the vector content onto the surfaces selected by the
+   *   value. Requires <code>options.scene</code>.
+   * @param {Scene} [options.scene] The scene the generated tileset is rendered in, required when
+   *   <code>options.heightReference</code> is a clamping value.
    */
   constructor(urlTemplate, options) {
     options = options ?? {};
@@ -61,6 +67,8 @@ class UrlTemplate3DTilesDataProvider {
     this._minZoom = options.minZoom ?? DEFAULT_MIN_ZOOM;
     this._maxZoom = options.maxZoom ?? DEFAULT_MAX_ZOOM;
     this._featureIdProperty = options.featureIdProperty;
+    this._heightReference = options.heightReference;
+    this._scene = options.scene;
     this._show = true;
     this._tileset = undefined;
     this._tilesetJsonUrl = undefined;
@@ -149,7 +157,10 @@ class UrlTemplate3DTilesDataProvider {
    * @returns {object}
    */
   _createTilesetLoadOptions() {
-    return {};
+    return {
+      heightReference: this._heightReference,
+      scene: this._scene,
+    };
   }
 
   /**

package/Source/Scene/VectorGltf3DTileContent.js

@@ -14,6 +14,7 @@ import Matrix4 from "../Core/Matrix4.js";
 import Model from "./Model/Model.js";
 import ModelUtility from "./Model/ModelUtility.js";
 import Pass from "../Renderer/Pass.js";
+import VectorProvider from "../Core/VectorProvider.js";
 import createVectorTileBuffersFromModelComponents from "./Model/createVectorTileBuffersFromModelComponents.js";
 import defined from "../Core/defined.js";
 import destroyObject from "../Core/destroyObject.js";
@@ -354,10 +355,17 @@ class VectorGltf3DTileContent {
         collection.modelMatrix,
       );
 
-      if (!isHeightReferenceClamp(tileset._heightReference)) {
+      if (
+        !isHeightReferenceClamp(tileset._heightReference) ||
+        !VectorProvider.isSupported(collection)
+      ) {
         collection.update(frameState);
       } else if (isSelected) {
-        vectorProvider.markSelected(collection, frameState.frameNumber);
+        vectorProvider.markForFrame(
+          collection,
+          frameState.frameNumber,
+          tileset._heightReference,
+        );
       }
     }
   }

package/Source/Scene/WebMapServiceImageryProvider.js

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

package/Source/Scene/WebMapTileServiceImageryProvider.js

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

package/Source/Scene/renderBufferPolylineCollection.js

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

package/Source/Shaders/BufferPolylineMaterialVS.glsl

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

package/Source/Shaders/BufferPolylineMaterialVS.js

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