@cesium/engine 14.0.0 → 16.0.0

package/Source/Scene/PropertyAttributeProperty.js

@@ -1,5 +1,5 @@
 import Check from "../Core/Check.js";
-import defaultValue from "../Core/defaultValue.js";
+import Frozen from "../Core/Frozen.js";
 import defined from "../Core/defined.js";
 
 /**
@@ -20,7 +20,7 @@ import defined from "../Core/defined.js";
  * @experimental This feature is using part of the 3D Tiles spec that is not final and is subject to change without Cesium's standard deprecation policy.
  */
 function PropertyAttributeProperty(options) {
-  options = defaultValue(options, defaultValue.EMPTY_OBJECT);
+  options = options ?? Frozen.EMPTY_OBJECT;
   const property = options.property;
   const classProperty = options.classProperty;
 
@@ -45,8 +45,8 @@ function PropertyAttributeProperty(options) {
   // the class property. The class property handles setting the default of
   // identity: (offset 0, scale 1) with the same scalar/vector/matrix types.
   // array types are disallowed by the spec.
-  offset = defaultValue(offset, classProperty.offset);
-  scale = defaultValue(scale, classProperty.scale);
+  offset = offset ?? classProperty.offset;
+  scale = scale ?? classProperty.scale;
 
   // offset and scale are applied on the GPU, so unpack the values
   // as math types we can use in uniform callbacks.

package/Source/Scene/PropertyTable.js

@@ -1,5 +1,5 @@
 import Check from "../Core/Check.js";
-import defaultValue from "../Core/defaultValue.js";
+import Frozen from "../Core/Frozen.js";
 import DeveloperError from "../Core/DeveloperError.js";
 import defined from "../Core/defined.js";
 import JsonMetadataTable from "./JsonMetadataTable.js";
@@ -38,7 +38,7 @@ import JsonMetadataTable from "./JsonMetadataTable.js";
  * @experimental This feature is using part of the 3D Tiles spec that is not final and is subject to change without Cesium's standard deprecation policy.
  */
 function PropertyTable(options) {
-  options = defaultValue(options, defaultValue.EMPTY_OBJECT);
+  options = options ?? Frozen.EMPTY_OBJECT;
 
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.number("options.count", options.count);

package/Source/Scene/PropertyTexture.js

@@ -1,5 +1,5 @@
 import Check from "../Core/Check.js";
-import defaultValue from "../Core/defaultValue.js";
+import Frozen from "../Core/Frozen.js";
 import defined from "../Core/defined.js";
 import PropertyTextureProperty from "./PropertyTextureProperty.js";
 
@@ -24,7 +24,7 @@ import PropertyTextureProperty from "./PropertyTextureProperty.js";
  * @experimental This feature is using part of the 3D Tiles spec that is not final and is subject to change without Cesium's standard deprecation policy.
  */
 function PropertyTexture(options) {
-  options = defaultValue(options, defaultValue.EMPTY_OBJECT);
+  options = options ?? Frozen.EMPTY_OBJECT;
   const propertyTexture = options.propertyTexture;
   const classDefinition = options.class;
   const textures = options.textures;

package/Source/Scene/PropertyTextureProperty.js

@@ -1,5 +1,5 @@
 import Check from "../Core/Check.js";
-import defaultValue from "../Core/defaultValue.js";
+import Frozen from "../Core/Frozen.js";
 import defined from "../Core/defined.js";
 import GltfLoaderUtil from "./GltfLoaderUtil.js";
 import MetadataType from "./MetadataType.js";
@@ -26,7 +26,7 @@ import oneTimeWarning from "../Core/oneTimeWarning.js";
  * @experimental This feature is using part of the 3D Tiles spec that is not final and is subject to change without Cesium's standard deprecation policy.
  */
 function PropertyTextureProperty(options) {
-  options = defaultValue(options, defaultValue.EMPTY_OBJECT);
+  options = options ?? Frozen.EMPTY_OBJECT;
   const property = options.property;
   const classProperty = options.classProperty;
   const textures = options.textures;
@@ -60,8 +60,8 @@ function PropertyTextureProperty(options) {
   // the class property. The class property handles setting the default of
   // identity: (offset 0, scale 1) with the same scalar/vector/matrix types.
   // array types are disallowed by the spec.
-  offset = defaultValue(offset, classProperty.offset);
-  scale = defaultValue(scale, classProperty.scale);
+  offset = offset ?? classProperty.offset;
+  scale = scale ?? classProperty.scale;
 
   // offset and scale are applied on the GPU, so unpack the values
   // as math types we can use in uniform callbacks.

package/Source/Scene/QuadtreePrimitive.js

@@ -1,6 +1,5 @@
 import Cartesian3 from "../Core/Cartesian3.js";
 import Cartographic from "../Core/Cartographic.js";
-import defaultValue from "../Core/defaultValue.js";
 import defined from "../Core/defined.js";
 import DeveloperError from "../Core/DeveloperError.js";
 import Event from "../Core/Event.js";
@@ -108,10 +107,7 @@ function QuadtreePrimitive(options) {
    * @type {number}
    * @default 2
    */
-  this.maximumScreenSpaceError = defaultValue(
-    options.maximumScreenSpaceError,
-    2,
-  );
+  this.maximumScreenSpaceError = options.maximumScreenSpaceError ?? 2;
 
   /**
    * Gets or sets the maximum number of tiles that will be retained in the tile cache.
@@ -121,7 +117,7 @@ function QuadtreePrimitive(options) {
    * @type {number}
    * @default 100
    */
-  this.tileCacheSize = defaultValue(options.tileCacheSize, 100);
+  this.tileCacheSize = options.tileCacheSize ?? 100;
 
   /**
    * Gets or sets the number of loading descendant tiles that is considered "too many".
@@ -1418,6 +1414,8 @@ function updateHeights(primitive, frameState) {
       ) {
         tryNextFrame.push(tile);
       }
+      // Ensure stale position cache is cleared
+      tile.clearPositionCache();
       tilesToUpdateHeights.shift();
       primitive._lastTileIndex = 0;
       continue;
@@ -1435,77 +1433,97 @@ function updateHeights(primitive, frameState) {
         defined(terrainData) && terrainData.wasCreatedByUpsampling();
 
       if (tile.level > data.level && !upsampledGeometryFromParent) {
-        if (!defined(data.positionOnEllipsoidSurface)) {
-          // cartesian has to be on the ellipsoid surface for `ellipsoid.geodeticSurfaceNormal`
-          data.positionOnEllipsoidSurface = Cartesian3.fromRadians(
-            data.positionCartographic.longitude,
-            data.positionCartographic.latitude,
-            0.0,
-            ellipsoid,
-          );
-        }
-
-        if (mode === SceneMode.SCENE3D) {
-          const surfaceNormal = ellipsoid.geodeticSurfaceNormal(
-            data.positionOnEllipsoidSurface,
-            scratchRay.direction,
-          );
+        let position;
+        // find cached entry
+        const cachedData = tile.getPositionCacheEntry(
+          data.positionCartographic,
+          primitive.maximumScreenSpaceError,
+        );
+        if (defined(cachedData)) {
+          // cache hit
+          position = cachedData;
+        } else {
+          if (!defined(data.positionOnEllipsoidSurface)) {
+            // cartesian has to be on the ellipsoid surface for `ellipsoid.geodeticSurfaceNormal`
+            data.positionOnEllipsoidSurface = Cartesian3.fromRadians(
+              data.positionCartographic.longitude,
+              data.positionCartographic.latitude,
+              0.0,
+              ellipsoid,
+            );
+          }
 
-          // compute origin point
+          if (mode === SceneMode.SCENE3D) {
+            const surfaceNormal = ellipsoid.geodeticSurfaceNormal(
+              data.positionOnEllipsoidSurface,
+              scratchRay.direction,
+            );
 
-          // Try to find the intersection point between the surface normal and z-axis.
-          // minimum height (-11500.0) for the terrain set, need to get this information from the terrain provider
-          const rayOrigin = ellipsoid.getSurfaceNormalIntersectionWithZAxis(
-            data.positionOnEllipsoidSurface,
-            11500.0,
-            scratchRay.origin,
-          );
+            // compute origin point
 
-          // Theoretically, not with Earth datums, the intersection point can be outside the ellipsoid
-          if (!defined(rayOrigin)) {
-            // intersection point is outside the ellipsoid, try other value
+            // Try to find the intersection point between the surface normal and z-axis.
             // minimum height (-11500.0) for the terrain set, need to get this information from the terrain provider
-            let minimumHeight = 0.0;
-            if (defined(tile.data.tileBoundingRegion)) {
-              minimumHeight = tile.data.tileBoundingRegion.minimumHeight;
-            }
-            const magnitude = Math.min(minimumHeight, -11500.0);
-
-            // multiply by the *positive* value of the magnitude
-            const vectorToMinimumPoint = Cartesian3.multiplyByScalar(
-              surfaceNormal,
-              Math.abs(magnitude) + 1,
-              scratchPosition,
-            );
-            Cartesian3.subtract(
+            const rayOrigin = ellipsoid.getSurfaceNormalIntersectionWithZAxis(
               data.positionOnEllipsoidSurface,
-              vectorToMinimumPoint,
+              11500.0,
               scratchRay.origin,
             );
+
+            // Theoretically, not with Earth datums, the intersection point can be outside the ellipsoid
+            if (!defined(rayOrigin)) {
+              // intersection point is outside the ellipsoid, try other value
+              // minimum height (-11500.0) for the terrain set, need to get this information from the terrain provider
+              let minimumHeight = 0.0;
+              if (defined(tile.data.tileBoundingRegion)) {
+                minimumHeight = tile.data.tileBoundingRegion.minimumHeight;
+              }
+              const magnitude = Math.min(minimumHeight, -11500.0);
+
+              // multiply by the *positive* value of the magnitude
+              const vectorToMinimumPoint = Cartesian3.multiplyByScalar(
+                surfaceNormal,
+                Math.abs(magnitude) + 1,
+                scratchPosition,
+              );
+              Cartesian3.subtract(
+                data.positionOnEllipsoidSurface,
+                vectorToMinimumPoint,
+                scratchRay.origin,
+              );
+            }
+          } else {
+            Cartographic.clone(data.positionCartographic, scratchCartographic);
+
+            // minimum height for the terrain set, need to get this information from the terrain provider
+            scratchCartographic.height = -11500.0;
+            projection.project(scratchCartographic, scratchPosition);
+            Cartesian3.fromElements(
+              scratchPosition.z,
+              scratchPosition.x,
+              scratchPosition.y,
+              scratchPosition,
+            );
+            Cartesian3.clone(scratchPosition, scratchRay.origin);
+            Cartesian3.clone(Cartesian3.UNIT_X, scratchRay.direction);
           }
-        } else {
-          Cartographic.clone(data.positionCartographic, scratchCartographic);
-
-          // minimum height for the terrain set, need to get this information from the terrain provider
-          scratchCartographic.height = -11500.0;
-          projection.project(scratchCartographic, scratchPosition);
-          Cartesian3.fromElements(
-            scratchPosition.z,
-            scratchPosition.x,
-            scratchPosition.y,
+
+          position = tile.data.pick(
+            scratchRay,
+            mode,
+            projection,
+            false,
             scratchPosition,
           );
-          Cartesian3.clone(scratchPosition, scratchRay.origin);
-          Cartesian3.clone(Cartesian3.UNIT_X, scratchRay.direction);
-        }
 
-        const position = tile.data.pick(
-          scratchRay,
-          mode,
-          projection,
-          false,
-          scratchPosition,
-        );
+          if (defined(position)) {
+            // Store the computed position in the cache for future reuse
+            tile.setPositionCacheEntry(
+              data.positionCartographic,
+              primitive.maximumScreenSpaceError,
+              position,
+            );
+          }
+        }
         if (defined(position)) {
           if (defined(data.callback)) {
             data.callback(position);

package/Source/Scene/QuadtreeTile.js

@@ -4,6 +4,45 @@ import Rectangle from "../Core/Rectangle.js";
 import QuadtreeTileLoadState from "./QuadtreeTileLoadState.js";
 import TileSelectionResult from "./TileSelectionResult.js";
 
+/**
+ * A simple Least Recently Used (LRU) cache implementation.
+ */
+class LRUCache {
+  constructor(maxSize) {
+    this.maxSize = maxSize;
+    this.cache = new Map();
+  }
+
+  get(key) {
+    if (!this.cache.has(key)) {
+      return undefined;
+    }
+    // Move accessed item to the end (most recently used)
+    const value = this.cache.get(key);
+    this.cache.delete(key);
+    this.cache.set(key, value);
+    return value;
+  }
+
+  set(key, value) {
+    if (this.cache.has(key)) {
+      this.cache.delete(key);
+    } else if (this.cache.size >= this.maxSize) {
+      // Remove the least recently used (first entry)
+      const firstKey = this.cache.keys().next().value;
+      this.cache.delete(firstKey);
+    }
+    this.cache.set(key, value);
+  }
+
+  clear() {
+    this.cache.clear();
+  }
+}
+
+// Maximum cache entries per tile
+const MAX_CACHE_ENTRIES = 1000;
+
 /**
  * A single tile in a {@link QuadtreePrimitive}.
  *
@@ -74,6 +113,9 @@ function QuadtreeTile(options) {
   this._lastSelectionResultFrame = undefined;
   this._loadedCallbacks = {};
 
+  // Cache for storing computed position values per tile to avoid redundant calculations
+  this._positionCache = new LRUCache(MAX_CACHE_ENTRIES);
+
   /**
    * Gets or sets the current state of the tile in the tile load pipeline.
    * @type {QuadtreeTileLoadState}
@@ -143,6 +185,132 @@ QuadtreeTile.createLevelZeroTiles = function (tilingScheme) {
   return result;
 };
 
+/**
+ * Creates a spatial hash key for the given longitude, latitude, and tile level.
+ * The precision is adjusted based on the tile level and extent to achieve finer precision at higher levels.
+ *
+ * This function calculates the spatial hash key by first determining the precision at the given tile for the current maximum screenspace error (MAX_ERROR_PX),
+ * and then rounding the longitude and latitude to that precision for consistency.
+ *
+ * The steps for computing the level precision are as follows:
+ *
+ * 1. Compute the resolution (meters per pixel) at the given level:
+ *      level_resolution_m = (2 * PI * RADIUS) / (2^level * TILE_SIZE)
+ *
+ * 2. Compute the target precision in meters:
+ *      level_precision_m = level_resolution_m * MAX_ERROR_PX
+ *
+ * 3. Compute the target precision to radians:
+ *      level_precision_rad = level_precision_m / BODY_RADIUS
+ *
+ * This simplifies to:
+ *      level_precision_rad = (2 * PI * MAX_ERROR_PX) / (2^level * TILE_SIZE)
+ * which can also be written as:
+ *      level_precision_rad = (PI * MAX_ERROR_PX) / (2^(level-1) * TILE_SIZE)
+ *
+ * The computed level_precision_rad is then used to round the input longitude and latitude,
+ * ensuring that positions that fall within the same spatial bin produce the same hash key.
+ *
+ * The constants below are computed once since they are fixed for the given configuration.
+ *
+ * @param {number} longitude - The longitude in radians.
+ * @param {number} latitude - The latitude in radians.
+ * @param {Rectangle} rectangle - The quadtree tile extents.
+ * @returns {string} A string representing the spatial hash key.
+ */
+const TILE_SIZE = 256;
+
+function createSpatialHashKey(
+  longitude,
+  latitude,
+  rectangle,
+  maximumScreenSpaceError,
+) {
+  // Adjust precision based on quadtree level - higher levels get finer precision
+  const maxError = (rectangle.width / TILE_SIZE) * maximumScreenSpaceError;
+  // Round to the grid precision
+  const lonGrid = Math.floor(longitude / maxError) * maxError;
+  const latGrid = Math.floor(latitude / maxError) * maxError;
+  return `${lonGrid.toFixed(10)},${latGrid.toFixed(10)}`;
+}
+
+/**
+ * Generates a unique cache key for a given cartographic position.
+ * @memberof QuadtreeTile
+ *
+ * @param {Cartographic} cartographic The cartographic coordinates.
+ * @param {number} maximumScreenSpaceError The maximum screen-space error, in pixels, that is allowed.
+ *        A higher maximum error will render fewer tiles and improve performance, while a lower
+ *        value will improve visual quality.
+ * @returns {string} A string representing the spatial hash key.
+ */
+QuadtreeTile.prototype._getCacheKey = function (
+  cartographic,
+  maximumScreenSpaceError,
+) {
+  return createSpatialHashKey(
+    cartographic.longitude,
+    cartographic.latitude,
+    this._rectangle,
+    maximumScreenSpaceError,
+  );
+};
+
+/**
+ * Retrieves a cached position for the specified cartographic position.
+ *
+ * @memberof QuadtreeTile
+ *
+ * @param {Cartographic} cartographic - The cartographic coordinates.
+ * @param {number} maximumScreenSpaceError The maximum screen-space error, in pixels, that is allowed.
+ *        A higher maximum error will render fewer tiles and improve performance, while a lower
+ *        value will improve visual quality.
+ * @returns {Object|undefined} The cached position data or undefined if not found.
+ */
+QuadtreeTile.prototype.getPositionCacheEntry = function (
+  cartographic,
+  maximumScreenSpaceError,
+) {
+  return this._positionCache.get(
+    this._getCacheKey(cartographic, maximumScreenSpaceError),
+  );
+};
+
+/**
+ * Sets a position on the cache for this tile.
+ *
+ * @memberof QuadtreeTile
+ *
+ * @param {Cartographic} cartographic - The cartographic coordinates.
+ * @param {number} maximumScreenSpaceError The maximum screen-space error, in pixels, that is allowed.
+ *        A higher maximum error will render fewer tiles and improve performance, while a lower
+ *        value will improve visual quality.
+ * @param {Object} value - The object to be cached.
+ */
+QuadtreeTile.prototype.setPositionCacheEntry = function (
+  cartographic,
+  maximumScreenSpaceError,
+  value,
+) {
+  this._positionCache.set(
+    this._getCacheKey(cartographic, maximumScreenSpaceError),
+    value,
+  );
+};
+
+/**
+ * Clears the position cache for this tile.
+ * This function removes all cached positions that were previously stored
+ * to optimize height computations.
+ *
+ * @memberof QuadtreeTile
+ */
+QuadtreeTile.prototype.clearPositionCache = function () {
+  if (this._positionCache.size > 0) {
+    this._positionCache.clear();
+  }
+};
+
 QuadtreeTile.prototype._updateCustomData = function (
   frameNumber,
   added,
@@ -513,6 +681,8 @@ QuadtreeTile.prototype.findTileToNorth = function (levelZeroTiles) {
  * @memberof QuadtreeTile
  */
 QuadtreeTile.prototype.freeResources = function () {
+  // Clears cached heights when the tile is freed
+  this.clearPositionCache();
   this.state = QuadtreeTileLoadState.START;
   this.renderable = false;
   this.upsampledFromParent = false;

package/Source/Scene/ResourceCache.js

@@ -1,5 +1,5 @@
 import Check from "../Core/Check.js";
-import defaultValue from "../Core/defaultValue.js";
+import Frozen from "../Core/Frozen.js";
 import defined from "../Core/defined.js";
 import DeveloperError from "../Core/DeveloperError.js";
 import BufferLoader from "./BufferLoader.js";
@@ -145,7 +145,7 @@ ResourceCache.unload = function (resourceLoader) {
  * @private
  */
 ResourceCache.getSchemaLoader = function (options) {
-  options = defaultValue(options, defaultValue.EMPTY_OBJECT);
+  options = options ?? Frozen.EMPTY_OBJECT;
   const { schema, resource } = options;
 
   //>>includeStart('debug', pragmas.debug);
@@ -187,7 +187,7 @@ ResourceCache.getSchemaLoader = function (options) {
  * @private
  */
 ResourceCache.getEmbeddedBufferLoader = function (options) {
-  options = defaultValue(options, defaultValue.EMPTY_OBJECT);
+  options = options ?? Frozen.EMPTY_OBJECT;
   const { parentResource, bufferId, typedArray } = options;
 
   //>>includeStart('debug', pragmas.debug);
@@ -227,7 +227,7 @@ ResourceCache.getEmbeddedBufferLoader = function (options) {
  * @private
  */
 ResourceCache.getExternalBufferLoader = function (options) {
-  options = defaultValue(options, defaultValue.EMPTY_OBJECT);
+  options = options ?? Frozen.EMPTY_OBJECT;
   const { resource } = options;
 
   //>>includeStart('debug', pragmas.debug);
@@ -264,7 +264,7 @@ ResourceCache.getExternalBufferLoader = function (options) {
  * @private
  */
 ResourceCache.getGltfJsonLoader = function (options) {
-  options = defaultValue(options, defaultValue.EMPTY_OBJECT);
+  options = options ?? Frozen.EMPTY_OBJECT;
   const { gltfResource, baseResource, typedArray, gltfJson } = options;
 
   //>>includeStart('debug', pragmas.debug);
@@ -306,7 +306,7 @@ ResourceCache.getGltfJsonLoader = function (options) {
  * @private
  */
 ResourceCache.getBufferViewLoader = function (options) {
-  options = defaultValue(options, defaultValue.EMPTY_OBJECT);
+  options = options ?? Frozen.EMPTY_OBJECT;
   const { gltf, bufferViewId, gltfResource, baseResource } = options;
 
   //>>includeStart('debug', pragmas.debug);
@@ -354,7 +354,7 @@ ResourceCache.getBufferViewLoader = function (options) {
  * @private
  */
 ResourceCache.getDracoLoader = function (options) {
-  options = defaultValue(options, defaultValue.EMPTY_OBJECT);
+  options = options ?? Frozen.EMPTY_OBJECT;
   const { gltf, primitive, draco, gltfResource, baseResource } = options;
 
   //>>includeStart('debug', pragmas.debug);
@@ -415,7 +415,7 @@ ResourceCache.getDracoLoader = function (options) {
  * @private
  */
 ResourceCache.getVertexBufferLoader = function (options) {
-  options = defaultValue(options, defaultValue.EMPTY_OBJECT);
+  options = options ?? Frozen.EMPTY_OBJECT;
   const {
     gltf,
     gltfResource,
@@ -544,7 +544,7 @@ function hasDracoCompression(draco, semantic) {
  * @private
  */
 ResourceCache.getIndexBufferLoader = function (options) {
-  options = defaultValue(options, defaultValue.EMPTY_OBJECT);
+  options = options ?? Frozen.EMPTY_OBJECT;
   const {
     gltf,
     accessorId,
@@ -617,7 +617,7 @@ ResourceCache.getIndexBufferLoader = function (options) {
  * @private
  */
 ResourceCache.getImageLoader = function (options) {
-  options = defaultValue(options, defaultValue.EMPTY_OBJECT);
+  options = options ?? Frozen.EMPTY_OBJECT;
   const { gltf, imageId, gltfResource, baseResource } = options;
 
   //>>includeStart('debug', pragmas.debug);
@@ -667,7 +667,7 @@ ResourceCache.getImageLoader = function (options) {
  * @private
  */
 ResourceCache.getTextureLoader = function (options) {
-  options = defaultValue(options, defaultValue.EMPTY_OBJECT);
+  options = options ?? Frozen.EMPTY_OBJECT;
   const {
     gltf,
     textureInfo,

package/Source/Scene/ResourceCacheKey.js

@@ -1,5 +1,5 @@
 import Check from "../Core/Check.js";
-import defaultValue from "../Core/defaultValue.js";
+import Frozen from "../Core/Frozen.js";
 import defined from "../Core/defined.js";
 import DeveloperError from "../Core/DeveloperError.js";
 import getAbsoluteUri from "../Core/getAbsoluteUri.js";
@@ -24,7 +24,7 @@ function getBufferViewCacheKey(bufferView) {
 
   if (hasExtension(bufferView, "EXT_meshopt_compression")) {
     const meshopt = bufferView.extensions.EXT_meshopt_compression;
-    byteOffset = defaultValue(meshopt.byteOffset, 0);
+    byteOffset = meshopt.byteOffset ?? 0;
     byteLength = meshopt.byteLength;
   }
 
@@ -148,7 +148,7 @@ ResourceCacheKey.getSchemaCacheKey = function (options) {
  * @private
  */
 ResourceCacheKey.getExternalBufferCacheKey = function (options) {
-  options = defaultValue(options, defaultValue.EMPTY_OBJECT);
+  options = options ?? Frozen.EMPTY_OBJECT;
   const { resource } = options;
 
   //>>includeStart('debug', pragmas.debug);
@@ -169,7 +169,7 @@ ResourceCacheKey.getExternalBufferCacheKey = function (options) {
  * @private
  */
 ResourceCacheKey.getEmbeddedBufferCacheKey = function (options) {
-  options = defaultValue(options, defaultValue.EMPTY_OBJECT);
+  options = options ?? Frozen.EMPTY_OBJECT;
   const { parentResource, bufferId } = options;
 
   //>>includeStart('debug', pragmas.debug);
@@ -193,7 +193,7 @@ ResourceCacheKey.getEmbeddedBufferCacheKey = function (options) {
  * @private
  */
 ResourceCacheKey.getGltfCacheKey = function (options) {
-  options = defaultValue(options, defaultValue.EMPTY_OBJECT);
+  options = options ?? Frozen.EMPTY_OBJECT;
   const { gltfResource } = options;
 
   //>>includeStart('debug', pragmas.debug);
@@ -216,7 +216,7 @@ ResourceCacheKey.getGltfCacheKey = function (options) {
  * @private
  */
 ResourceCacheKey.getBufferViewCacheKey = function (options) {
-  options = defaultValue(options, defaultValue.EMPTY_OBJECT);
+  options = options ?? Frozen.EMPTY_OBJECT;
   const { gltf, bufferViewId, gltfResource, baseResource } = options;
 
   //>>includeStart('debug', pragmas.debug);
@@ -259,7 +259,7 @@ ResourceCacheKey.getBufferViewCacheKey = function (options) {
  * @private
  */
 ResourceCacheKey.getDracoCacheKey = function (options) {
-  options = defaultValue(options, defaultValue.EMPTY_OBJECT);
+  options = options ?? Frozen.EMPTY_OBJECT;
   const { gltf, draco, gltfResource, baseResource } = options;
 
   //>>includeStart('debug', pragmas.debug);
@@ -293,7 +293,7 @@ ResourceCacheKey.getDracoCacheKey = function (options) {
  * @private
  */
 ResourceCacheKey.getVertexBufferCacheKey = function (options) {
-  options = defaultValue(options, defaultValue.EMPTY_OBJECT);
+  options = options ?? Frozen.EMPTY_OBJECT;
   const {
     gltf,
     gltfResource,
@@ -406,7 +406,7 @@ function hasDracoCompression(draco, semantic) {
  * @private
  */
 ResourceCacheKey.getIndexBufferCacheKey = function (options) {
-  options = defaultValue(options, defaultValue.EMPTY_OBJECT);
+  options = options ?? Frozen.EMPTY_OBJECT;
   const {
     gltf,
     accessorId,
@@ -483,7 +483,7 @@ ResourceCacheKey.getIndexBufferCacheKey = function (options) {
  * @private
  */
 ResourceCacheKey.getImageCacheKey = function (options) {
-  options = defaultValue(options, defaultValue.EMPTY_OBJECT);
+  options = options ?? Frozen.EMPTY_OBJECT;
   const { gltf, imageId, gltfResource, baseResource } = options;
 
   //>>includeStart('debug', pragmas.debug);
@@ -518,7 +518,7 @@ ResourceCacheKey.getImageCacheKey = function (options) {
  * @private
  */
 ResourceCacheKey.getTextureCacheKey = function (options) {
-  options = defaultValue(options, defaultValue.EMPTY_OBJECT);
+  options = options ?? Frozen.EMPTY_OBJECT;
   const {
     gltf,
     textureInfo,