@cesium/engine 26.2.0 → 26.3.0

package/Source/Scene/BufferPrimitiveCollection.js

@@ -14,6 +14,7 @@ import SceneMode from "./SceneMode.js";
 import AttributeType from "./AttributeType.js";
 import oneTimeWarning from "../Core/oneTimeWarning.js";
 import BlendOption from "../Scene/BlendOption.js";
+import HeightReference, { isHeightReferenceClamp } from "./HeightReference.js";
 
 /** @import { Destroyable, TypedArray, TypedArrayConstructor } from "../Core/globalTypes.js"; */
 /** @import Context from "../Renderer/Context.js"; */
@@ -32,6 +33,31 @@ import BlendOption from "../Scene/BlendOption.js";
  * @experimental This feature is not final and is subject to change without Cesium's standard deprecation policy.
  */
 
+/**
+ * @typedef {object} BufferPrimitiveCollectionOptions
+ * @property {Matrix4} [modelMatrix=Matrix4.IDENTITY] Transforms geometry from model to world coordinates.
+ * @property {number} [primitiveCountMax=BufferPrimitiveCollection.DEFAULT_CAPACITY] Maximum number of primitives.
+ * @property {number} [vertexCountMax=BufferPrimitiveCollection.DEFAULT_CAPACITY] Maximum number of vertices.
+ * @property {boolean} [show=true]
+ * @property {ComponentDatatype} [positionDatatype=ComponentDatatype.DOUBLE] The component datatype used to store position values.
+ * @property {boolean} [positionNormalized=false] When <code>true</code>, integer position values are treated as normalized,
+ *   where the full integer range maps to [-1, 1] (signed) or [0, 1] (unsigned). Only relevant for integer position datatypes
+ *   (BYTE, UNSIGNED_BYTE, SHORT, UNSIGNED_SHORT).
+ * @property {boolean} [allowPicking=false] When <code>true</code>, primitives are pickable with {@link Scene#pick}. When <code>false</code>, memory and initialization cost are lower.
+ * @property {BoundingSphere} [boundingVolume] Bounding volume, in world space, for the collection. When
+ *    unspecified, a bounding volume is computed automatically and updated when primitive positions change. When
+ *    specified, users are responsible for updating bounding volume as needed. Pre-computing the bounding volume
+ *    manually, and updating it only as needed, will improve performance for larger dynamic collections.
+ * @property {boolean} [debugShowBoundingVolume=false]
+ * @property {BlendOption} [blendOption=BlendOption.TRANSLUCENT]
+ * @property {HeightReference} [options.heightReference=HeightReference.NONE] When set to a clamping value, the
+ *   collection is draped onto the surfaces selected by the value: {@link HeightReference.CLAMP_TO_TERRAIN} drapes
+ *   onto the globe, {@link HeightReference.CLAMP_TO_3D_TILE} drapes onto 3D Tiles, and
+ *   {@link HeightReference.CLAMP_TO_GROUND} drapes onto both. Only {@link BufferPolylineCollection} and
+ *   {@link BufferPolygonCollection} support draping, and only once the collection has been added to
+ *   {@link Scene#primitives}. A draped collection is not also drawn as geometry of its own.
+ */
+
 /**
  * Collection of primitives held in ArrayBuffer storage for performance and memory optimization.
  *
@@ -71,22 +97,7 @@ class BufferPrimitiveCollection {
   _renderContext = null;
 
   /**
-   * @param {object} options
-   * @param {Matrix4} [options.modelMatrix=Matrix4.IDENTITY] Transforms geometry from model to world coordinates.
-   * @param {number} [options.primitiveCountMax=BufferPrimitiveCollection.DEFAULT_CAPACITY]
-   * @param {number} [options.vertexCountMax=BufferPrimitiveCollection.DEFAULT_CAPACITY]
-   * @param {boolean} [options.show=true]
-   * @param {ComponentDatatype} [options.positionDatatype=ComponentDatatype.DOUBLE]
-   * @param {boolean} [options.positionNormalized=false] When <code>true</code>, integer position values are treated as normalized,
-   *   where the full integer range maps to [-1, 1] (signed) or [0, 1] (unsigned). Only relevant for integer position datatypes
-   *   (BYTE, UNSIGNED_BYTE, SHORT, UNSIGNED_SHORT).
-   * @param {boolean} [options.allowPicking=false] When <code>true</code>, primitives are pickable with {@link Scene#pick}. When <code>false</code>, memory and initialization cost are lower.
-   * @param {BoundingSphere} [options.boundingVolume] Bounding volume, in world space, for the collection. When
-   *    unspecified, a bounding volume is computed automatically and updated when primitive positions change. When
-   *    specified, users are responsible for updating bounding volume as needed. Pre-computing the bounding volume
-   *    manually, and updating it only as needed, will improve performance for larger dynamic collections.
-   * @param {boolean} [options.debugShowBoundingVolume=false]
-   * @param {BlendOption} [options.blendOption=BlendOption.TRANSLUCENT]
+   * @param {BufferPrimitiveCollectionOptions} [options]
    */
   constructor(options = Frozen.EMPTY_OBJECT) {
     /**
@@ -96,6 +107,13 @@ class BufferPrimitiveCollection {
      */
     this.show = options.show ?? true;
 
+    /**
+     * @type {HeightReference}
+     * @readonly
+     * @protected
+     */
+    this._heightReference = options.heightReference ?? HeightReference.NONE;
+
     /**
      * Collection blend option; must be OPAQUE or TRANSLUCENT.
      * @type {BlendOption}
@@ -148,11 +166,14 @@ class BufferPrimitiveCollection {
     this._pickIds = new Map();
 
     /**
+     * User-defined pick objects. Primitives without custom pick objects will have default
+     * pick objects assigned instead.
+     *
      * @type {object[]}
      * @readonly
      * @ignore
      */
-    this._pickObjects = [];
+    this._customPickObjects = [];
 
     /**
      * This property is for debugging only; it is not for production use nor is it optimized.
@@ -342,7 +363,7 @@ class BufferPrimitiveCollection {
 
   /** Destroys collection and its GPU resources. */
   destroy() {
-    this._pickObjects.length = 0;
+    this._customPickObjects.length = 0;
 
     for (const contextPickIds of this._pickIds.values()) {
       for (const pickId of contextPickIds) {
@@ -394,7 +415,7 @@ class BufferPrimitiveCollection {
     }
 
     // Copy primitives to temporary collection, in sort order.
-    const tmp = CollectionClass._cloneEmpty(this);
+    const tmp = this._cloneEmpty();
     for (let i = 0; i < primitiveCount; i++) {
       const src = this.get(dstSrcMap[i], a);
       const dst = tmp.add({}, b);
@@ -424,9 +445,14 @@ class BufferPrimitiveCollection {
    *
    * @param {BufferPrimitiveCollection<T>} collection
    * @param {BufferPrimitiveCollection<T>} result
+   * @param {function(BufferPrimitive, number): boolean} [predicate] When provided, only primitives for which this returns <code>true</code> are copied. Surviving primitives are compacted into contiguous indices.
    * @template T extends BufferPrimitive
    */
-  static clone(collection, result) {
+  static clone(collection, result, predicate) {
+    if (defined(predicate)) {
+      return this._cloneFiltered(collection, result, predicate);
+    }
+
     //>>includeStart('debug', pragmas.debug);
     const { ERR_CAPACITY } = BufferPrimitiveCollection.Error;
     assert(collection.primitiveCount <= result.primitiveCountMax, ERR_CAPACITY);
@@ -455,14 +481,19 @@ class BufferPrimitiveCollection {
       collection.primitiveCount * MaterialClass.packedLength,
     );
 
-    result.show = collection.show;
-    result.debugShowBoundingVolume = collection.debugShowBoundingVolume;
+    // Collection-level display flags (show, debugShowBoundingVolume) are carried
+    // by the constructor, so they are intentionally not copied here.
     result._primitiveCount = collection._primitiveCount;
     result._positionCount = collection._positionCount;
 
-    // Unset PickIds.
+    // Copy per-primitive pick objects and unset each GPU PickId.
+    // PickIds are regenerated for the result collection on next render.
+    const srcPickObjects = collection._customPickObjects;
+    const dstPickObjects = result._customPickObjects;
+    dstPickObjects.length = 0;
     const primitive = new PrimitiveClass();
     for (let i = 0, il = result.primitiveCount; i < il; i++) {
+      dstPickObjects[i] = srcPickObjects[i];
       result.get(i, primitive)._pickId = 0;
     }
 
@@ -475,17 +506,123 @@ class BufferPrimitiveCollection {
   }
 
   /**
-   * Returns an empty collection with the same buffer sizes as this collection.
-   * Internal utility for operations requiring a working copy of memory.
+   * Filtered variant of {@link BufferPrimitiveCollection.clone}. Copies
+   * primitive-by-primitive via {@link BufferPrimitive.clone}, so it handles
+   * subclass data generically and needs no per-subclass override.
    *
    * @param {BufferPrimitiveCollection<T>} collection
+   * @param {BufferPrimitiveCollection<T>} result
+   * @param {function(BufferPrimitive, number): boolean} predicate
+   * @template T extends BufferPrimitive
+   * @protected
+   * @ignore
+   */
+  static _cloneFiltered(collection, result, predicate) {
+    const PrimitiveClass = collection._getPrimitiveClass();
+    const src = new PrimitiveClass();
+    const dst = new PrimitiveClass();
+
+    const srcPickObjects = collection._customPickObjects;
+    const dstPickObjects = result._customPickObjects;
+    dstPickObjects.length = 0;
+
+    for (let i = 0, il = collection._primitiveCount; i < il; i++) {
+      collection.get(i, src);
+      if (!predicate(src, i)) {
+        continue;
+      }
+
+      const dstIndex = result._primitiveCount;
+      PrimitiveClass.clone(src, result.add({}, dst));
+
+      if (defined(srcPickObjects[i])) {
+        dstPickObjects[dstIndex] = srcPickObjects[i];
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Returns a copy of the given collection, overriding any constructor options
+   * provided. Omitted options are inherited from the source collection. Any
+   * resized buffers must be large enough to hold every primitive.
+   *
+   * <p>Collection-level state (model matrix, blend option, picking, bounding-volume
+   * mode, etc.) is carried over, but GPU resources are not: the source collection
+   * retains ownership of its renderer resources, so the caller is responsible for
+   * calling {@link BufferPrimitiveCollection#destroy} on the source once it is no
+   * longer needed.</p>
+   *
+   * @example
+   * const grown = BufferPrimitiveCollection.fromCollection(collection, {
+   *   primitiveCountMax: collection.primitiveCountMax * 2,
+   *   vertexCountMax: collection.vertexCountMax * 2,
+   * });
+   * collection.destroy(); // release the source collection's GPU resources
+   *
+   * @example
+   * // Grow while dropping hidden primitives.
+   * const compacted = BufferPrimitiveCollection.fromCollection(
+   *   collection,
+   *   { primitiveCountMax: collection.primitiveCountMax * 2 },
+   *   (primitive) => primitive.show,
+   * );
+   *
+   * @param {BufferPrimitiveCollection<T>} collection Source collection to copy.
+   * @param {BufferPrimitiveCollectionOptions} [options] Constructor options to override. Omitted options are inherited from the source collection.
+   * @param {function(BufferPrimitive, number): boolean} [predicate] When provided, only primitives for which this returns <code>true</code> are copied. Surviving primitives are compacted into contiguous indices.
    * @returns {BufferPrimitiveCollection<T>}
    * @template T extends BufferPrimitive
+   */
+  static fromCollection(collection, options = Frozen.EMPTY_OBJECT, predicate) {
+    const result = collection._cloneEmpty(options);
+    collection._getCollectionClass().clone(collection, result, predicate);
+    return result;
+  }
+
+  /**
+   * Base constructor arguments that carry over collection-level state to an
+   * empty copy created by {@link BufferPrimitiveCollection.fromCollection}.
+   * Subclasses should spread the result into their constructor arguments,
+   * adding any type-specific options. Provided options override inherited
+   * state; omitted options are inherited from this collection.
+   *
+   * @param {BufferPrimitiveCollectionOptions} options
+   * @returns {object}
+   * @protected
+   * @ignore
+   */
+  _cloneEmptyBaseArgs(options) {
+    return {
+      primitiveCountMax: this.primitiveCountMax,
+      vertexCountMax: this.vertexCountMax,
+      positionDatatype: this.positionDatatype,
+      positionNormalized: this.positionNormalized,
+      modelMatrix: this._modelMatrix,
+      show: this.show,
+      debugShowBoundingVolume: this.debugShowBoundingVolume,
+      blendOption: this._blendOption,
+      allowPicking: this._allowPicking,
+      boundingVolume: this._boundingVolumeAutoUpdate
+        ? undefined
+        : this._boundingVolume,
+      ...options,
+    };
+  }
+
+  /**
+   * Returns an empty collection with the same structure as this one, overriding
+   * any constructor options provided. Omitted options are inherited from this
+   * collection.
+   *
+   * @param {BufferPrimitiveCollectionOptions} [options]
+   * @returns {BufferPrimitiveCollection<T>}
    * @protected
    * @abstract
    * @ignore
    */
-  static _cloneEmpty(collection) {
+  _cloneEmpty(options) {
     DeveloperError.throwInstantiationError();
   }
 
@@ -566,7 +703,7 @@ class BufferPrimitiveCollection {
     for (let i = pickIds.length, il = this._primitiveCount; i < il; i++) {
       this.get(i, primitive);
 
-      const pickObject = this._pickObjects[i] || {
+      const pickObject = this._customPickObjects[i] || {
         collection: this,
         index: i,
         get primitive() {
@@ -644,7 +781,7 @@ class BufferPrimitiveCollection {
     result._dirty = true;
 
     if (defined(options.pickObject)) {
-      this._pickObjects[index] = options.pickObject;
+      this._customPickObjects[index] = options.pickObject;
     }
 
     return result;
@@ -705,11 +842,31 @@ class BufferPrimitiveCollection {
     if (this._dirtyBoundingVolume) {
       this._updateBoundingVolume();
     }
-    if (this._allowPicking && this._dirtyCount > 0) {
+    // Not gated on the dirty count: a draped collection is packed by a surface,
+    // which may read the ids and mark the collection clean before this runs.
+    if (this._allowPicking) {
       this._updatePickIds(/** @type {FrameState} */ (frameState).context);
     }
   }
 
+  /**
+   * Whether the collection draws itself this frame. A draped collection is
+   * rendered by the surface it is draped onto.
+   *
+   * @param {FrameState} frameState
+   * @returns {boolean}
+   * @protected
+   * @ignore
+   */
+  _isRendered(frameState) {
+    const passes = frameState.passes;
+    return (
+      this.show &&
+      !isHeightReferenceClamp(this._heightReference) &&
+      (passes.render || passes.pick)
+    );
+  }
+
   /////////////////////////////////////////////////////////////////////////////
   // ACCESSORS
 
@@ -816,6 +973,19 @@ class BufferPrimitiveCollection {
     return this._positionNormalized;
   }
 
+  /**
+   * Determines which surfaces the collection is draped onto, in addition to
+   * being drawn as standalone geometry. Draping requires that the collection
+   * has been added to {@link Scene#primitives}.
+   *
+   * @type {HeightReference}
+   * @readonly
+   * @default HeightReference.NONE
+   */
+  get heightReference() {
+    return this._heightReference;
+  }
+
   /////////////////////////////////////////////////////////////////////////////
   // UTILS
 

package/Source/Scene/Cesium3DTile.js

@@ -438,6 +438,16 @@ function Cesium3DTile(tileset, baseResource, header, parent) {
    */
   this.clippingPolygonsDirty = false;
 
+  /**
+   * Tracks if the tileset's ClippingPolygonCollection's geometry changed (a polygon was added or removed),
+   * which requires the tile's content to rebake its clipping textures.
+   *
+   * @type {boolean}
+   *
+   * @private
+   */
+  this.clippingPolygonsNeedRebake = false;
+
   /**
    * Tracks if the tile's request should be deferred until all non-deferred
    * tiles load.
@@ -1483,6 +1493,7 @@ Cesium3DTile.prototype.unloadContent = function () {
   this._clippingPlanesState = 0;
   this.clippingPolygonsDirty = this._clippingPolygonsState === 0;
   this._clippingPolygonsState = 0;
+  this.clippingPolygonsNeedRebake = false;
 
   this._debugColorizeTiles = false;
 
@@ -2315,6 +2326,7 @@ Cesium3DTile.prototype.update = function (tileset, frameState, passOptions) {
 
   this.clippingPlanesDirty = false; // reset after content update
   this.clippingPolygonsDirty = false;
+  this.clippingPolygonsNeedRebake = false;
 };
 
 const scratchCommandList = [];

package/Source/Scene/Cesium3DTileset.js

@@ -11,6 +11,7 @@ import Frozen from "../Core/Frozen.js";
 import defined from "../Core/defined.js";
 import deprecationWarning from "../Core/deprecationWarning.js";
 import destroyObject from "../Core/destroyObject.js";
+import DeveloperError from "../Core/DeveloperError.js";
 import Ellipsoid from "../Core/Ellipsoid.js";
 import Event from "../Core/Event.js";
 import ImageBasedLighting from "./ImageBasedLighting.js";
@@ -44,6 +45,7 @@ import ClippingPlaneCollection from "./ClippingPlaneCollection.js";
 import ClippingPolygonCollection from "./ClippingPolygonCollection.js";
 import EdgeDisplayMode from "./EdgeDisplayMode.js";
 import hasExtension from "./hasExtension.js";
+import { isHeightReferenceClamp } from "./HeightReference.js";
 import ImplicitTileset from "./ImplicitTileset.js";
 import ImplicitTileCoordinates from "./ImplicitTileCoordinates.js";
 import LabelCollection from "./LabelCollection.js";
@@ -153,6 +155,7 @@ import ImageryLayerCollection from "./ImageryLayerCollection.js";
  * @param {Cesium3DTileset.ConstructorOptions} options An object describing initialization options
  *
  * @exception {DeveloperError} The tileset must be 3D Tiles version 0.0 or 1.0.
+ * @exception {DeveloperError} Height reference is not supported without a scene.
  *
  * @example
  * try {
@@ -343,6 +346,14 @@ function Cesium3DTileset(options) {
   this._heightReference = options.heightReference;
   this._scene = options.scene;
 
+  //>>includeStart('debug', pragmas.debug);
+  if (isHeightReferenceClamp(this._heightReference) && !defined(this._scene)) {
+    throw new DeveloperError(
+      "Height reference is not supported without a scene.",
+    );
+  }
+  //>>includeEnd('debug');
+
   this._ellipsoid = options.ellipsoid ?? Ellipsoid.WGS84;
 
   this._initialClippingPlanesOriginMatrix = Matrix4.IDENTITY; // Computed from the tileset JSON.
@@ -856,12 +867,16 @@ function Cesium3DTileset(options) {
   }
 
   this._clippingPolygons = undefined;
+  this._clippingPolygonsNeedRebake = false;
+  this._removeClippingPolygonAdded = undefined;
+  this._removeClippingPolygonRemoved = undefined;
   if (defined(options.clippingPolygons)) {
     ClippingPolygonCollection.setOwner(
       options.clippingPolygons,
       this,
       "_clippingPolygons",
     );
+    updateTilesetClippingPolygonListeners(this);
   }
 
   if (defined(options.imageBasedLighting)) {
@@ -1193,6 +1208,8 @@ Object.defineProperties(Cesium3DTileset.prototype, {
     },
     set: function (value) {
       ClippingPolygonCollection.setOwner(value, this, "_clippingPolygons");
+      updateTilesetClippingPolygonListeners(this);
+      this._clippingPolygonsNeedRebake = true;
     },
   },
 
@@ -2693,6 +2710,34 @@ Cesium3DTileset.prototype.postPassesUpdate = function (frameState) {
   this._styleApplied = false;
 };
 
+/**
+ * Subscribes the owning tileset to its clipping polygon add/remove events so
+ * tile content can rebake clipping textures when the geometry changes.
+ * @private
+ * @param {Cesium3DTileset} tileset
+ */
+function updateTilesetClippingPolygonListeners(tileset) {
+  tileset._removeClippingPolygonAdded =
+    tileset._removeClippingPolygonAdded &&
+    tileset._removeClippingPolygonAdded();
+  tileset._removeClippingPolygonRemoved =
+    tileset._removeClippingPolygonRemoved &&
+    tileset._removeClippingPolygonRemoved();
+
+  const clippingPolygons = tileset._clippingPolygons;
+  if (!defined(clippingPolygons)) {
+    return;
+  }
+
+  const markDirty = () => {
+    tileset._clippingPolygonsNeedRebake = true;
+  };
+  tileset._removeClippingPolygonAdded =
+    clippingPolygons.polygonAdded.addEventListener(markDirty);
+  tileset._removeClippingPolygonRemoved =
+    clippingPolygons.polygonRemoved.addEventListener(markDirty);
+}
+
 /**
  * Perform any pass invariant tasks here. Called before any passes are executed.
  * @ignore
@@ -2718,6 +2763,15 @@ Cesium3DTileset.prototype.prePassesUpdate = function (frameState) {
     clippingPolygons.update(frameState);
   }
 
+  // After a polygon add/remove, mark loaded tiles so their content rebakes
+  // clipping textures. Done once per frame to dedupe multiple changes.
+  if (this._clippingPolygonsNeedRebake) {
+    this._clippingPolygonsNeedRebake = false;
+    this._cache.forEachLoadedTile((tile) => {
+      tile.clippingPolygonsNeedRebake = true;
+    });
+  }
+
   if (!defined(this._loadTimestamp)) {
     this._loadTimestamp = JulianDate.clone(frameState.time);
   }
@@ -3579,12 +3633,6 @@ Cesium3DTileset.prototype.updateForPass = function (
     environmentMapManager.update(frameState);
   }
 
-  // Update clipping polygons
-  const clippingPolygons = this._clippingPolygons;
-  if (defined(clippingPolygons) && clippingPolygons.enabled) {
-    clippingPolygons.queueCommands(frameState);
-  }
-
   const passStatistics = this._statisticsPerPass[pass];
 
   if (this.show || ignoreCommands) {
@@ -3652,9 +3700,14 @@ Cesium3DTileset.prototype.isDestroyed = function () {
 Cesium3DTileset.prototype.destroy = function () {
   this._tileDebugLabels =
     this._tileDebugLabels && this._tileDebugLabels.destroy();
+
+  this._removeClippingPolygonAdded =
+    this._removeClippingPolygonAdded && this._removeClippingPolygonAdded();
+  this._removeClippingPolygonRemoved =
+    this._removeClippingPolygonRemoved && this._removeClippingPolygonRemoved();
+
   this._clippingPlanes = this._clippingPlanes && this._clippingPlanes.destroy();
-  this._clippingPolygons =
-    this._clippingPolygons && this._clippingPolygons.destroy();
+  this._clippingPolygons = undefined;
 
   // Traverse the tree and destroy all tiles
   if (defined(this._root)) {

package/Source/Scene/Cesium3DTilesetBaseTraversal.js

@@ -247,6 +247,13 @@ function executeTraversal(root, frameState) {
 function executeEmptyTraversal(root, frameState) {
   const { canTraverse, updateTile, loadTile, touchTile } =
     Cesium3DTilesetTraversal;
+  // Vector tilesets opt into relaxed empty-tile refinement so empty regions reached
+  // through implicit or external placeholders do not block their content siblings.
+  // Note: it's likely we don't need to limit this behavior to vector tilesets. However,
+  // we are being cautious of breaking changes to existing tilesets.
+  const isVectorTileset = root.tileset.hasExtension(
+    "3DTILES_content_gltf_vector",
+  );
   let allDescendantsLoaded = true;
   const stack = emptyTraversal.stack;
   stack.push(root);
@@ -264,9 +271,14 @@ function executeEmptyTraversal(root, frameState) {
     // Only traverse if the tile is empty - traversal stops at descendants with content
     const traverse = !tile.hasRenderableContent && canTraverse(tile);
 
-    // Traversal stops but the tile does not have content yet
-    // There will be holes if the parent tries to refine to its children, so don't refine
-    if (!traverse && !tile.contentAvailable) {
+    // For vector tilesets only unloaded renderable content blocks refinement, so an empty
+    // tile at its resolved level of detail does not hold back its content siblings,
+    // including across implicit or external placeholders. All other tilesets keep the
+    // original behavior of blocking whenever traversal stops without content available.
+    const blocksRefinement = isVectorTileset
+      ? tile.hasRenderableContent
+      : !traverse;
+    if (blocksRefinement && !tile.contentAvailable) {
       allDescendantsLoaded = false;
     }
 

package/Source/Scene/Cesium3DTilesetCache.js

@@ -34,6 +34,21 @@ Cesium3DTilesetCache.prototype.add = function (tile) {
   }
 };
 
+/**
+ * Invokes the callback for each tile with loaded content in the cache.
+ *
+ * @param {Function} callback A function that takes a {@link Cesium3DTile}.
+ * @private
+ */
+Cesium3DTilesetCache.prototype.forEachLoadedTile = function (callback) {
+  for (let node = this._list.head; defined(node); node = node.next) {
+    // The sentinel node has no item.
+    if (defined(node.item)) {
+      callback(node.item);
+    }
+  }
+};
+
 Cesium3DTilesetCache.prototype.unloadTile = function (
   tileset,
   tile,