@cesium/engine 2.4.1 → 3.0.0

package/Source/Scene/Cesium3DTileset.js

@@ -61,14 +61,15 @@ import Cesium3DTilesetSkipTraversal from "./Cesium3DTilesetSkipTraversal.js";
  *
  * Initialization options for the Cesium3DTileset constructor
  *
- * @property {Resource|string|Promise<Resource>|Promise<string>} [.url] The url to a tileset JSON file. Deprecated.
  * @property {boolean} [show=true] Determines if the tileset will be shown.
  * @property {Matrix4} [modelMatrix=Matrix4.IDENTITY] A 4x4 transformation matrix that transforms the tileset's root tile.
  * @property {Axis} [modelUpAxis=Axis.Y] Which axis is considered up when loading models for tile contents.
  * @property {Axis} [modelForwardAxis=Axis.X] Which axis is considered forward when loading models for tile contents.
  * @property {ShadowMode} [shadows=ShadowMode.ENABLED] Determines whether the tileset casts or receives shadows from light sources.
  * @property {number} [maximumScreenSpaceError=16] The maximum screen space error used to drive level of detail refinement.
- * @property {number} [maximumMemoryUsage=512] The maximum amount of memory in MB that can be used by the tileset.
+ * @property {number} [maximumMemoryUsage=512] The maximum amount of memory in MB that can be used by the tileset. Deprecated.
+ * @property {number} [cacheBytes=536870912] The size (in bytes) to which the tile cache will be trimmed, if the cache contains tiles not needed for the current view.
+ * @property {number} [maximumCacheOverflowBytes=536870912] The maximum additional memory (in bytes) to allow for cache headroom, if more than {@link Cesium3DTileset#cacheBytes} are needed for the current view.
  * @property {boolean} [cullWithChildrenBounds=true] Optimization option. Whether to cull tiles using the union of their children bounding volumes.
  * @property {boolean} [cullRequestsWhileMoving=true] Optimization option. Don't request tiles that will likely be unused when they come back because of the camera's movement. This optimization only applies to stationary tilesets.
  * @property {number} [cullRequestsWhileMovingMultiplier=60.0] Optimization option. Multiplier used in culling requests while moving. Larger is more aggressive culling, smaller less aggressive culling.
@@ -221,7 +222,33 @@ function Cesium3DTileset(options) {
     options.maximumScreenSpaceError,
     16
   );
-  this._maximumMemoryUsage = defaultValue(options.maximumMemoryUsage, 512);
+  this._memoryAdjustedScreenSpaceError = this._maximumScreenSpaceError;
+
+  let defaultCacheBytes = 512 * 1024 * 1024;
+  if (defined(options.maximumMemoryUsage)) {
+    deprecationWarning(
+      "Cesium3DTileset.maximumMemoryUsage",
+      "Cesium3DTileset.maximumMemoryUsage was deprecated in CesiumJS 1.107.  It will be removed in CesiumJS 1.110. Use Cesium3DTileset.cacheBytes instead."
+    );
+    defaultCacheBytes = options.maximumMemoryUsage * 1024 * 1024;
+  }
+  this._cacheBytes = defaultValue(options.cacheBytes, defaultCacheBytes);
+  //>>includeStart('debug', pragmas.debug);
+  Check.typeOf.number.greaterThanOrEquals("cacheBytes", this._cacheBytes, 0);
+  //>>includeEnd('debug');
+
+  const maximumCacheOverflowBytes = defaultValue(
+    options.maximumCacheOverflowBytes,
+    512 * 1024 * 1024
+  );
+  //>>includeStart('debug', pragmas.debug);
+  Check.typeOf.number.greaterThanOrEquals(
+    "maximumCacheOverflowBytes",
+    maximumCacheOverflowBytes,
+    0
+  );
+  //>>includeEnd('debug');
+  this._maximumCacheOverflowBytes = maximumCacheOverflowBytes;
 
   this._styleEngine = new Cesium3DTileStyleEngine();
   this._styleApplied = false;
@@ -590,7 +617,7 @@ function Cesium3DTileset(options) {
    *     console.log('A tile was unloaded from the cache.');
    * });
    *
-   * @see Cesium3DTileset#maximumMemoryUsage
+   * @see Cesium3DTileset#cacheBytes
    * @see Cesium3DTileset#trimLoadedTiles
    */
   this.tileUnload = new Event();
@@ -990,124 +1017,6 @@ function Cesium3DTileset(options) {
     instanceFeatureIdLabel = `instanceFeatureId_${instanceFeatureIdLabel}`;
   }
   this._instanceFeatureIdLabel = instanceFeatureIdLabel;
-
-  if (defined(options.url)) {
-    deprecationWarning(
-      "Cesium3DTileset options.url",
-      "Cesium3DTileset constructor parameter options.url was deprecated in CesiumJS 1.104. It will be removed in 1.107. Use Cesium3DTileset.fromUrl instead."
-    );
-    const that = this;
-    let resource;
-    this._readyPromise = Promise.resolve(options.url)
-      .then(function (url) {
-        let basePath;
-        resource = Resource.createIfNeeded(url);
-        that._resource = resource;
-
-        // ion resources have a credits property we can use for additional attribution.
-        that._credits = resource.credits;
-
-        if (resource.extension === "json") {
-          basePath = resource.getBaseUri(true);
-        } else if (resource.isDataUri) {
-          basePath = "";
-        }
-
-        that._url = resource.url;
-        that._basePath = basePath;
-
-        return Cesium3DTileset.loadJson(resource);
-      })
-      .then(function (tilesetJson) {
-        if (that.isDestroyed()) {
-          return;
-        }
-
-        // This needs to be called before loadTileset() so tile metadata
-        // can be initialized synchronously in the Cesium3DTile constructor
-        return processMetadataExtension(resource, tilesetJson).then(
-          (metadata) => {
-            that._metadataExtension = metadata;
-            return tilesetJson;
-          }
-        );
-      })
-      .then(function (tilesetJson) {
-        if (that.isDestroyed()) {
-          return;
-        }
-
-        // Set these before loading the tileset since _geometricError
-        // and _scaledGeometricError get accessed during tile creation
-        that._geometricError = tilesetJson.geometricError;
-        that._scaledGeometricError = tilesetJson.geometricError;
-
-        that._root = that.loadTileset(resource, tilesetJson);
-
-        // Handle legacy gltfUpAxis option
-        const gltfUpAxis = defined(tilesetJson.asset.gltfUpAxis)
-          ? Axis.fromName(tilesetJson.asset.gltfUpAxis)
-          : Axis.Y;
-        const modelUpAxis = defaultValue(options.modelUpAxis, gltfUpAxis);
-        const modelForwardAxis = defaultValue(options.modelForwardAxis, Axis.X);
-
-        const asset = tilesetJson.asset;
-        that._asset = asset;
-        that._properties = tilesetJson.properties;
-        that._extensionsUsed = tilesetJson.extensionsUsed;
-        that._extensions = tilesetJson.extensions;
-        that._modelUpAxis = modelUpAxis;
-        that._modelForwardAxis = modelForwardAxis;
-        that._extras = tilesetJson.extras;
-
-        const extras = asset.extras;
-        if (
-          defined(extras) &&
-          defined(extras.cesium) &&
-          defined(extras.cesium.credits)
-        ) {
-          const extraCredits = extras.cesium.credits;
-          let credits = that._credits;
-          if (!defined(credits)) {
-            credits = [];
-            that._credits = credits;
-          }
-          for (let i = 0; i < extraCredits.length; ++i) {
-            const credit = extraCredits[i];
-            credits.push(new Credit(credit.html, that._showCreditsOnScreen));
-          }
-        }
-
-        // Save the original, untransformed bounding volume position so we can apply
-        // the tile transform and model matrix at run time
-        const boundingVolume = that._root.createBoundingVolume(
-          tilesetJson.root.boundingVolume,
-          Matrix4.IDENTITY
-        );
-        const clippingPlanesOrigin = boundingVolume.boundingSphere.center;
-        // If this origin is above the surface of the earth
-        // we want to apply an ENU orientation as our best guess of orientation.
-        // Otherwise, we assume it gets its position/orientation completely from the
-        // root tile transform and the tileset's model matrix
-        const originCartographic = that._ellipsoid.cartesianToCartographic(
-          clippingPlanesOrigin
-        );
-        if (
-          defined(originCartographic) &&
-          originCartographic.height >
-            ApproximateTerrainHeights._defaultMinTerrainHeight
-        ) {
-          that._initialClippingPlanesOriginMatrix = Transforms.eastNorthUpToFixedFrame(
-            clippingPlanesOrigin
-          );
-        }
-        that._clippingPlanesOriginMatrix = Matrix4.clone(
-          that._initialClippingPlanesOriginMatrix
-        );
-
-        return that;
-      });
-  }
 }
 
 Object.defineProperties(Cesium3DTileset.prototype, {
@@ -1196,59 +1105,6 @@ Object.defineProperties(Cesium3DTileset.prototype, {
     },
   },
 
-  /**
-   * When <code>true</code>, the tileset's root tile is loaded and the tileset is ready to render.
-   *
-   * @memberof Cesium3DTileset.prototype
-   *
-   * @type {boolean}
-   * @readonly
-   *
-   * @default false
-   */
-  ready: {
-    get: function () {
-      deprecationWarning(
-        "Cesium3DTileset.ready",
-        "Cesium3DTileset.ready was deprecated in CesiumJS 1.104. It will be removed in 1.107. Use Cesium3DTileset.fromUrl instead."
-      );
-      return defined(this._root);
-    },
-  },
-
-  /**
-   * Gets the promise that will be resolved when the tileset's root tile is loaded and the tileset is ready to render.
-   * <p>
-   * This promise is resolved at the end of the frame before the first frame the tileset is rendered in.
-   * </p>
-   *
-   * @memberof Cesium3DTileset.prototype
-   *
-   * @type {Promise<Cesium3DTileset>}
-   * @readonly
-   * @deprecated
-   *
-   * @example
-   * tileset.readyPromise.then(function(tileset) {
-   *     // tile.properties is not defined until readyPromise resolves.
-   *     const properties = tileset.properties;
-   *     if (Cesium.defined(properties)) {
-   *         for (const name in properties) {
-   *             console.log(properties[name]);
-   *         }
-   *     }
-   * });
-   */
-  readyPromise: {
-    get: function () {
-      deprecationWarning(
-        "Cesium3DTileset.readyPromise",
-        "Cesium3DTileset.readyPromise was deprecated in CesiumJS 1.104. It will be removed in 1.107. Use Cesium3DTileset.fromUrl instead."
-      );
-      return this._readyPromise;
-    },
-  },
-
   /**
    * When <code>true</code>, all tiles that meet the screen space error this frame are loaded. The tileset is
    * completely loaded for this view.
@@ -1516,6 +1372,7 @@ Object.defineProperties(Cesium3DTileset.prototype, {
       //>>includeEnd('debug');
 
       this._maximumScreenSpaceError = value;
+      this._memoryAdjustedScreenSpaceError = value;
     },
   },
 
@@ -1545,17 +1402,122 @@ Object.defineProperties(Cesium3DTileset.prototype, {
    *
    * @exception {DeveloperError} <code>maximumMemoryUsage</code> must be greater than or equal to zero.
    * @see Cesium3DTileset#totalMemoryUsageInBytes
+   *
+   * @deprecated
    */
   maximumMemoryUsage: {
     get: function () {
+      deprecationWarning(
+        "Cesium3DTileset.maximumMemoryUsage",
+        "Cesium3DTileset.maximumMemoryUsage was deprecated in CesiumJS 1.107.  It will be removed in CesiumJS 1.110. Use Cesium3DTileset.cacheBytes instead."
+      );
       return this._maximumMemoryUsage;
     },
     set: function (value) {
+      deprecationWarning(
+        "Cesium3DTileset.maximumMemoryUsage",
+        "Cesium3DTileset.maximumMemoryUsage was deprecated in CesiumJS 1.107.  It will be removed in CesiumJS 1.110. Use Cesium3DTileset.cacheBytes instead."
+      );
       //>>includeStart('debug', pragmas.debug);
       Check.typeOf.number.greaterThanOrEquals("value", value, 0);
       //>>includeEnd('debug');
 
       this._maximumMemoryUsage = value;
+      this._cacheBytes = value * 1024 * 1024;
+    },
+  },
+
+  /**
+   * The amount of GPU memory (in bytes) used to cache tiles. This memory usage is estimated from
+   * geometry, textures, and batch table textures of loaded tiles. For point clouds, this value also
+   * includes per-point metadata.
+   * <p>
+   * Tiles not in view are unloaded to enforce this.
+   * </p>
+   * <p>
+   * If decreasing this value results in unloading tiles, the tiles are unloaded the next frame.
+   * </p>
+   * <p>
+   * If tiles sized more than <code>cacheBytes</code> are needed to meet the
+   * desired screen space error, determined by {@link Cesium3DTileset#maximumScreenSpaceError},
+   * for the current view, then the memory usage of the tiles loaded will exceed
+   * <code>cacheBytes</code> by up to <code>maximumCacheOverflowBytes</code>.
+   * For example, if <code>cacheBytes</code> is 500000, but 600000 bytes
+   * of tiles are needed to meet the screen space error, then 600000 bytes of tiles
+   * may be loaded (if <code>maximumCacheOverflowBytes</code> is at least 100000).
+   * When these tiles go out of view, they will be unloaded.
+   * </p>
+   *
+   * @memberof Cesium3DTileset.prototype
+   *
+   * @type {number}
+   * @default 536870912
+   *
+   * @exception {DeveloperError} <code>cacheBytes</code> must be typeof 'number' and greater than or equal to 0
+   * @see Cesium3DTileset#totalMemoryUsageInBytes
+   */
+  cacheBytes: {
+    get: function () {
+      return this._cacheBytes;
+    },
+    set: function (value) {
+      //>>includeStart('debug', pragmas.debug);
+      Check.typeOf.number.greaterThanOrEquals("value", value, 0);
+      //>>includeEnd('debug');
+
+      this._cacheBytes = value;
+    },
+  },
+
+  /**
+   * The maximum additional amount of GPU memory (in bytes) that will be used to cache tiles.
+   * <p>
+   * If tiles sized more than <code>cacheBytes</code> plus <code>maximumCacheOverflowBytes</code>
+   * are needed to meet the desired screen space error, determined by
+   * {@link Cesium3DTileset#maximumScreenSpaceError} for the current view, then
+   * {@link Cesium3DTileset#memoryAdjustedScreenSpaceError} will be adjusted
+   * until the tiles required to meet the adjusted screen space error use less
+   * than <code>cacheBytes</code> plus <code>maximumCacheOverflowBytes</code>.
+   * </p>
+   *
+   * @memberof Cesium3DTileset.prototype
+   *
+   * @type {number}
+   * @default 536870912
+   *
+   * @exception {DeveloperError} <code>maximumCacheOverflowBytes</code> must be typeof 'number' and greater than or equal to 0
+   * @see Cesium3DTileset#totalMemoryUsageInBytes
+   */
+  maximumCacheOverflowBytes: {
+    get: function () {
+      return this._maximumCacheOverflowBytes;
+    },
+    set: function (value) {
+      //>>includeStart('debug', pragmas.debug);
+      Check.typeOf.number.greaterThanOrEquals("value", value, 0);
+      //>>includeEnd('debug');
+
+      this._maximumCacheOverflowBytes = value;
+    },
+  },
+
+  /**
+   * If loading the level of detail required by @{link Cesium3DTileset#maximumScreenSpaceError}
+   * results in the memory usage exceeding @{link Cesium3DTileset#cacheBytes}
+   * plus @{link Cesium3DTileset#maximumCacheOverflowBytes}, level of detail refinement
+   * will instead use this (larger) adjusted screen space error to achieve the
+   * best possible visual quality within the available memory
+   *
+   * @memberof Cesium3DTileset.prototype
+   *
+   * @type {number}
+   * @readonly
+   *
+   * @private
+   */
+  memoryAdjustedScreenSpaceError: {
+    get: function () {
+      return this._memoryAdjustedScreenSpaceError;
     },
   },
 
@@ -1665,7 +1627,7 @@ Object.defineProperties(Cesium3DTileset.prototype, {
    * @type {number}
    * @readonly
    *
-   * @see Cesium3DTileset#maximumMemoryUsage
+   * @see Cesium3DTileset#cacheBytes
    */
   totalMemoryUsageInBytes: {
     get: function () {
@@ -2167,8 +2129,6 @@ Cesium3DTileset.fromUrl = async function (url, options) {
     tileset._initialClippingPlanesOriginMatrix
   );
 
-  tileset._readyPromise = Promise.resolve(tileset);
-  tileset._ready = true;
   return tileset;
 };
 
@@ -2524,7 +2484,7 @@ function requestContent(tileset, tile) {
   tileset._requestedTilesInFlight.push(tile);
 }
 
-function sortRequestByPriority(a, b) {
+function sortTilesByPriority(a, b) {
   return a._priority - b._priority;
 }
 
@@ -2627,7 +2587,7 @@ function cancelOutOfViewRequests(tileset, frameState) {
  */
 function requestTiles(tileset) {
   const requestedTiles = tileset._requestedTiles;
-  requestedTiles.sort(sortRequestByPriority);
+  requestedTiles.sort(sortTilesByPriority);
   for (let i = 0; i < requestedTiles.length; ++i) {
     requestContent(tileset, requestedTiles[i]);
   }
@@ -2694,10 +2654,18 @@ function filterProcessingQueue(tileset) {
 function processTiles(tileset, frameState) {
   filterProcessingQueue(tileset);
   const tiles = tileset._processingQueue;
-  const statistics = tileset._statistics;
-  let tile;
+
+  const { cacheBytes, maximumCacheOverflowBytes, statistics } = tileset;
+  const cacheByteLimit = cacheBytes + maximumCacheOverflowBytes;
+
+  let memoryExceeded = false;
   for (let i = 0; i < tiles.length; ++i) {
-    tile = tiles[i];
+    if (tileset.totalMemoryUsageInBytes > cacheByteLimit) {
+      memoryExceeded = true;
+      break;
+    }
+
+    const tile = tiles[i];
     try {
       tile.process(tileset, frameState);
 
@@ -2710,6 +2678,37 @@ function processTiles(tileset, frameState) {
       handleTileFailure(error, tileset, tile);
     }
   }
+
+  if (tileset.totalMemoryUsageInBytes < cacheBytes) {
+    decreaseScreenSpaceError(tileset);
+  } else if (memoryExceeded && tiles.length > 0) {
+    increaseScreenSpaceError(tileset);
+  }
+}
+
+function increaseScreenSpaceError(tileset) {
+  //>>includeStart('debug', pragmas.debug);
+  oneTimeWarning(
+    "increase-screenSpaceError",
+    `The tiles needed to meet maximumScreenSpaceError would use more memory than allocated for this tileset.
+    The tileset will be rendered with a larger screen space error (see memoryAdjustedScreenSpaceError).
+    Consider using larger values for cacheBytes and maximumCacheOverflowBytes.`
+  );
+  //>>includeEnd('debug');
+
+  tileset._memoryAdjustedScreenSpaceError *= 1.02;
+  const tiles = tileset._processingQueue;
+  for (let i = 0; i < tiles.length; ++i) {
+    tiles[i].updatePriority();
+  }
+  tiles.sort(sortTilesByPriority);
+}
+
+function decreaseScreenSpaceError(tileset) {
+  tileset._memoryAdjustedScreenSpaceError = Math.max(
+    tileset.memoryAdjustedScreenSpaceError / 1.02,
+    tileset.maximumScreenSpaceError
+  );
 }
 
 const scratchCartesian = new Cartesian3();
@@ -3057,7 +3056,7 @@ function destroyTile(tileset, tile) {
 /**
  * Unloads all tiles that weren't selected the previous frame.  This can be used to
  * explicitly manage the tile cache and reduce the total number of tiles loaded below
- * {@link Cesium3DTileset#maximumMemoryUsage}.
+ * {@link Cesium3DTileset#cacheBytes}.
  * <p>
  * Tile unloads occur at the next frame to keep all the WebGL delete calls
  * within the render loop.

package/Source/Scene/Cesium3DTilesetBaseTraversal.js

@@ -53,7 +53,7 @@ Cesium3DTilesetBaseTraversal.selectTiles = function (tileset, frameState) {
 
   if (
     root.getScreenSpaceError(frameState, true) <=
-    tileset._maximumScreenSpaceError
+    tileset.memoryAdjustedScreenSpaceError
   ) {
     return;
   }

package/Source/Scene/Cesium3DTilesetCache.js

@@ -58,8 +58,6 @@ Cesium3DTilesetCache.prototype.unloadTiles = function (
 
   const list = this._list;
 
-  const maximumMemoryUsageInBytes = tileset.maximumMemoryUsage * 1024 * 1024;
-
   // Traverse the list only to the sentinel since tiles/nodes to the
   // right of the sentinel were used this frame.
   //
@@ -68,7 +66,7 @@ Cesium3DTilesetCache.prototype.unloadTiles = function (
   let node = list.head;
   while (
     node !== sentinel &&
-    (tileset.totalMemoryUsageInBytes > maximumMemoryUsageInBytes || trimTiles)
+    (tileset.totalMemoryUsageInBytes > tileset.cacheBytes || trimTiles)
   ) {
     const tile = node.item;
     node = node.next;

package/Source/Scene/Cesium3DTilesetSkipTraversal.js

@@ -61,7 +61,7 @@ Cesium3DTilesetSkipTraversal.selectTiles = function (tileset, frameState) {
 
   if (
     root.getScreenSpaceError(frameState, true) <=
-    tileset._maximumScreenSpaceError
+    tileset.memoryAdjustedScreenSpaceError
   ) {
     return;
   }
@@ -267,7 +267,10 @@ function executeTraversal(root, frameState) {
   const { tileset } = root;
   const baseScreenSpaceError = tileset.immediatelyLoadDesiredLevelOfDetail
     ? Number.MAX_VALUE
-    : Math.max(tileset.baseScreenSpaceError, tileset.maximumScreenSpaceError);
+    : Math.max(
+        tileset.baseScreenSpaceError,
+        tileset.memoryAdjustedScreenSpaceError
+      );
   const {
     canTraverse,
     loadTile,

package/Source/Scene/Cesium3DTilesetTraversal.js

@@ -64,7 +64,7 @@ Cesium3DTilesetTraversal.canTraverse = function (tile) {
     // Don't traverse if the subtree is expired because it will be destroyed
     return !tile.contentExpired;
   }
-  return tile._screenSpaceError > tile.tileset._maximumScreenSpaceError;
+  return tile._screenSpaceError > tile.tileset.memoryAdjustedScreenSpaceError;
 };
 
 /**
@@ -260,7 +260,7 @@ function meetsScreenSpaceErrorEarly(tile, frameState) {
   // Use parent's geometric error with child's box to see if the tile already meet the SSE
   return (
     tile.getScreenSpaceError(frameState, true) <=
-    tileset._maximumScreenSpaceError
+    tileset.memoryAdjustedScreenSpaceError
   );
 }
 

package/Source/Scene/ClassificationPrimitive.js

@@ -2,7 +2,6 @@ import ColorGeometryInstanceAttribute from "../Core/ColorGeometryInstanceAttribu
 import combine from "../Core/combine.js";
 import defaultValue from "../Core/defaultValue.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 GeometryInstance from "../Core/GeometryInstance.js";
@@ -163,30 +162,6 @@ function ClassificationPrimitive(options) {
   this._commandsIgnoreShow = [];
 
   this._ready = false;
-
-  const classificationPrimitive = this;
-  // This is here for backwards compatibility. This promise wrapper can be removed once readyPromise is removed.
-  this._readyPromise = new Promise((resolve, reject) => {
-    classificationPrimitive._completeLoad = () => {
-      if (this._ready) {
-        return;
-      }
-
-      this._ready = true;
-
-      if (this.releaseGeometryInstances) {
-        this.geometryInstances = undefined;
-      }
-
-      const error = this._error;
-      if (!defined(error)) {
-        resolve(this);
-      } else {
-        reject(error);
-      }
-    };
-  });
-
   this._primitive = undefined;
   this._pickPrimitive = options._pickPrimitive;
 
@@ -337,23 +312,6 @@ Object.defineProperties(ClassificationPrimitive.prototype, {
     },
   },
 
-  /**
-   * Gets a promise that resolves when the primitive is ready to render.
-   * @memberof ClassificationPrimitive.prototype
-   * @type {Promise<ClassificationPrimitive>}
-   * @readonly
-   * @deprecated
-   */
-  readyPromise: {
-    get: function () {
-      deprecationWarning(
-        "ClassificationPrimitive.readyPromise",
-        "ClassificationPrimitive.readyPromise was deprecated in CesiumJS 1.104. It will be removed in 1.107. Wait for ClassificationPrimitive.ready to return true instead."
-      );
-      return this._readyPromise;
-    },
-  },
-
   /**
    * Returns true if the ClassificationPrimitive needs a separate shader and commands for 2D.
    * This is because texture coordinates on ClassificationPrimitives are computed differently,
@@ -1359,7 +1317,11 @@ ClassificationPrimitive.prototype.update = function (frameState) {
 
   frameState.afterRender.push(() => {
     if (defined(this._primitive) && this._primitive.ready) {
-      this._completeLoad();
+      this._ready = true;
+
+      if (this.releaseGeometryInstances) {
+        this.geometryInstances = undefined;
+      }
     }
   });
 };

package/Source/Scene/Composite3DTileContent.js

@@ -1,6 +1,5 @@
 import defaultValue from "../Core/defaultValue.js";
 import defined from "../Core/defined.js";
-import deprecationWarning from "../Core/deprecationWarning.js";
 import destroyObject from "../Core/destroyObject.js";
 import getMagic from "../Core/getMagic.js";
 import RuntimeError from "../Core/RuntimeError.js";
@@ -31,11 +30,6 @@ function Composite3DTileContent(tileset, tile, resource, contents) {
   this._metadata = undefined;
   this._group = undefined;
   this._ready = false;
-
-  this._resolveContent = undefined;
-  this._readyPromise = new Promise((resolve) => {
-    this._resolveContent = resolve;
-  });
 }
 
 Object.defineProperties(Composite3DTileContent.prototype, {
@@ -147,26 +141,6 @@ Object.defineProperties(Composite3DTileContent.prototype, {
     },
   },
 
-  /**
-   * Gets the promise that will be resolved when the tile's content is ready to render.
-   *
-   * @memberof Composite3DTileContent.prototype
-   *
-   * @type {Promise<Composite3DTileContent>}
-   * @readonly
-   * @deprecated
-   * @private
-   */
-  readyPromise: {
-    get: function () {
-      deprecationWarning(
-        "Composite3DTileContent.readyPromise",
-        "Composite3DTileContent.readyPromise was deprecated in CesiumJS 1.104. It will be removed in 1.107. Wait for Composite3DTileContent.ready to return true instead."
-      );
-      return this._readyPromise;
-    },
-  },
-
   tileset: {
     get: function () {
       return this._tileset;
@@ -370,7 +344,6 @@ Composite3DTileContent.prototype.update = function (tileset, frameState) {
 
   if (!this._ready && ready) {
     this._ready = true;
-    this._resolveContent(this);
   }
 };