@cesium/engine 26.2.0 → 26.3.1-wasm.0

package/Source/Scene/Model/ModelSceneGraph.js

@@ -14,6 +14,7 @@ import ModelArticulation from "./ModelArticulation.js";
 import ModelColorPipelineStage from "./ModelColorPipelineStage.js";
 import ModelClippingPlanesPipelineStage from "./ModelClippingPlanesPipelineStage.js";
 import ModelClippingPolygonsPipelineStage from "./ModelClippingPolygonsPipelineStage.js";
+import ModelVectorLookupPipelineStage from "./ModelVectorLookupPipelineStage.js";
 import ModelNode from "./ModelNode.js";
 import ModelRuntimeNode from "./ModelRuntimeNode.js";
 import ModelRuntimePrimitive from "./ModelRuntimePrimitive.js";
@@ -735,10 +736,18 @@ ModelSceneGraph.prototype.configurePipeline = function (frameState) {
     modelPipelineStages.push(ModelClippingPlanesPipelineStage);
   }
 
-  if (model.isClippingPolygonsEnabled()) {
+  // Even if a model has a clipping polygon collection, the polygons may not overlap the model geometry,
+  // in which case the clipping polygon pipeline stage should not be added.
+  const hasClippingPolygonGeometry =
+    (model._clippingPolygonData?.polygonRings.length ?? 0) > 0;
+  if (model.isClippingPolygonsEnabled() && hasClippingPolygonGeometry) {
     modelPipelineStages.push(ModelClippingPolygonsPipelineStage);
   }
 
+  if (model.hasDrapedVectors()) {
+    modelPipelineStages.push(ModelVectorLookupPipelineStage);
+  }
+
   if (model.hasSilhouette(frameState)) {
     modelPipelineStages.push(ModelSilhouettePipelineStage);
   }

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/SpzDecoder.js

@@ -0,0 +1,106 @@
+import defined from "../Core/defined.js";
+import DeveloperError from "../Core/DeveloperError.js";
+import getAbsoluteUri from "../Core/getAbsoluteUri.js";
+import TaskProcessor from "../Core/TaskProcessor.js";
+
+const defaultWorkerModuleId = "decodeSpz";
+
+function getDecoderTaskProcessor() {
+  let taskProcessor = SpzDecoder._decoderTaskProcessor;
+  if (!defined(taskProcessor)) {
+    const workerModuleUrl = SpzDecoder._workerModuleUrl;
+    const workerPath = defined(workerModuleUrl)
+      ? getAbsoluteUri(workerModuleUrl)
+      : defaultWorkerModuleId;
+    taskProcessor = new TaskProcessor(workerPath);
+    SpzDecoder._decoderTaskProcessor = taskProcessor;
+  }
+
+  return taskProcessor;
+}
+
+/**
+ * Configures the Web Worker module used to decode SPZ-compressed Gaussian
+ * splats.
+ *
+ * @alias SpzDecoder
+ * @namespace
+ *
+ * @experimental This feature is not final and is subject to change without
+ * Cesium's standard deprecation policy.
+ */
+function SpzDecoder() {}
+
+Object.defineProperties(SpzDecoder, {
+  /**
+   * The URL of the ECMAScript Web Worker module that decodes SPZ data. Set
+   * this before the first SPZ decode to use a decoder other than Cesium's
+   * bundled <code>Workers/decodeSpz.js</code> worker. Relative URLs are
+   * resolved relative to the document URL.
+   *
+   * To apply a separate Content Security Policy to the decoder, serve the
+   * module as a separate, same-origin resource. Cross-origin URLs use a
+   * <code>blob:</code> worker fallback, which inherits the document's policy.
+   *
+   * The module must use {@link createTaskProcessorWorker}, receive an object
+   * with a <code>spzData</code> {@link Uint8Array}, and return the gcloud
+   * object produced by <code>@spz-loader/core</code>. It must transfer the
+   * buffers for its typed-array attributes.
+   *
+   * @memberof SpzDecoder
+   * @type {string|undefined}
+   * @default undefined
+   * @experimental This feature is not final and is subject to change without
+   * Cesium's standard deprecation policy.
+   */
+  workerModuleUrl: {
+    get: function () {
+      return SpzDecoder._workerModuleUrl;
+    },
+    set: function (value) {
+      if (defined(SpzDecoder._decoderTaskProcessor)) {
+        throw new DeveloperError(
+          "SpzDecoder.workerModuleUrl must be configured before the first SPZ decode.",
+        );
+      }
+
+      if (defined(value) && (typeof value !== "string" || value.length === 0)) {
+        throw new DeveloperError(
+          "SpzDecoder.workerModuleUrl must be a non-empty string or undefined.",
+        );
+      }
+
+      SpzDecoder._workerModuleUrl = value;
+    },
+  },
+});
+
+/**
+ * Decodes SPZ data in the configured Web Worker.
+ *
+ * @param {Uint8Array} spzData The compressed SPZ data. Its backing buffer is
+ *        transferred to the worker.
+ * @returns {Promise<object>|undefined} A promise that resolves to the gcloud
+ *          decode result, or undefined when the worker is busy.
+ * @private
+ */
+SpzDecoder.decode = function (spzData) {
+  return getDecoderTaskProcessor().scheduleTask({ spzData: spzData }, [
+    spzData.buffer,
+  ]);
+};
+
+SpzDecoder._decoderTaskProcessor = undefined;
+SpzDecoder._workerModuleUrl = undefined;
+
+// Exposed for testing purposes.
+SpzDecoder._resetForTesting = function () {
+  const taskProcessor = SpzDecoder._decoderTaskProcessor;
+  if (defined(taskProcessor) && !taskProcessor.isDestroyed()) {
+    taskProcessor.destroy();
+  }
+  SpzDecoder._decoderTaskProcessor = undefined;
+  SpzDecoder._workerModuleUrl = undefined;
+};
+
+export default SpzDecoder;

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,
+        );
       }
     }
   }