@cesium/engine 14.0.0 → 16.0.0

package/Source/Scene/MapboxImageryProvider.js

@@ -1,5 +1,5 @@
 import Credit from "../Core/Credit.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 Resource from "../Core/Resource.js";
@@ -47,7 +47,7 @@ const defaultCredit = new Credit(
  * @see {@link https://docs.mapbox.com/api/accounts/tokens/}
  */
 function MapboxImageryProvider(options) {
-  options = defaultValue(options, defaultValue.EMPTY_OBJECT);
+  options = options ?? Frozen.EMPTY_OBJECT;
   const mapId = options.mapId;
   //>>includeStart('debug', pragmas.debug);
   if (!defined(mapId)) {
@@ -74,13 +74,13 @@ function MapboxImageryProvider(options) {
   this._defaultMagnificationFilter = undefined;
 
   const resource = Resource.createIfNeeded(
-    defaultValue(options.url, "https://{s}.tiles.mapbox.com/v4/"),
+    options.url ?? "https://{s}.tiles.mapbox.com/v4/",
   );
 
   this._mapId = mapId;
   this._accessToken = accessToken;
 
-  let format = defaultValue(options.format, "png");
+  let format = options.format ?? "png";
   if (!/\./.test(format)) {
     format = `.${format}`;
   }

package/Source/Scene/MapboxStyleImageryProvider.js

@@ -1,5 +1,5 @@
 import Credit from "../Core/Credit.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 Resource from "../Core/Resource.js";
@@ -49,7 +49,7 @@ const defaultCredit = new Credit(
  * @see {@link https://docs.mapbox.com/api/#access-tokens-and-token-scopes}
  */
 function MapboxStyleImageryProvider(options) {
-  options = defaultValue(options, defaultValue.EMPTY_OBJECT);
+  options = options ?? Frozen.EMPTY_OBJECT;
   const styleId = options.styleId;
   //>>includeStart('debug', pragmas.debug);
   if (!defined(styleId)) {
@@ -76,16 +76,16 @@ function MapboxStyleImageryProvider(options) {
   this._defaultMagnificationFilter = undefined;
 
   const resource = Resource.createIfNeeded(
-    defaultValue(options.url, "https://api.mapbox.com/styles/v1/"),
+    options.url ?? "https://api.mapbox.com/styles/v1/",
   );
 
   this._styleId = styleId;
   this._accessToken = accessToken;
 
-  const tilesize = defaultValue(options.tilesize, 512);
+  const tilesize = options.tilesize ?? 512;
   this._tilesize = tilesize;
 
-  const username = defaultValue(options.username, "mapbox");
+  const username = options.username ?? "mapbox";
   this._username = username;
 
   const scaleFactor = defined(options.scaleFactor) ? "@2x" : "";

package/Source/Scene/Material.js

@@ -3,7 +3,7 @@ import clone from "../Core/clone.js";
 import Color from "../Core/Color.js";
 import combine from "../Core/combine.js";
 import createGuid from "../Core/createGuid.js";
-import defaultValue from "../Core/defaultValue.js";
+import Frozen from "../Core/Frozen.js";
 import defined from "../Core/defined.js";
 import destroyObject from "../Core/destroyObject.js";
 import DeveloperError from "../Core/DeveloperError.js";
@@ -308,14 +308,10 @@ function Material(options) {
    */
   this.translucent = undefined;
 
-  this._minificationFilter = defaultValue(
-    options.minificationFilter,
-    TextureMinificationFilter.LINEAR,
-  );
-  this._magnificationFilter = defaultValue(
-    options.magnificationFilter,
-    TextureMagnificationFilter.LINEAR,
-  );
+  this._minificationFilter =
+    options.minificationFilter ?? TextureMinificationFilter.LINEAR;
+  this._magnificationFilter =
+    options.magnificationFilter ?? TextureMagnificationFilter.LINEAR;
 
   this._strict = undefined;
   this._template = undefined;
@@ -586,17 +582,15 @@ Material.prototype.destroy = function () {
 };
 
 function initializeMaterial(options, result) {
-  options = defaultValue(options, defaultValue.EMPTY_OBJECT);
-  result._strict = defaultValue(options.strict, false);
-  result._count = defaultValue(options.count, 0);
-  result._template = clone(
-    defaultValue(options.fabric, defaultValue.EMPTY_OBJECT),
-  );
+  options = options ?? Frozen.EMPTY_OBJECT;
+  result._strict = options.strict ?? false;
+  result._count = options.count ?? 0;
+  result._template = clone(options.fabric ?? Frozen.EMPTY_OBJECT);
   result._template.uniforms = clone(
-    defaultValue(result._template.uniforms, defaultValue.EMPTY_OBJECT),
+    result._template.uniforms ?? Frozen.EMPTY_OBJECT,
   );
   result._template.materials = clone(
-    defaultValue(result._template.materials, defaultValue.EMPTY_OBJECT),
+    result._template.materials ?? Frozen.EMPTY_OBJECT,
   );
 
   result.type = defined(result._template.type)
@@ -633,8 +627,8 @@ function initializeMaterial(options, result) {
 
   const defaultTranslucent =
     result._translucentFunctions.length === 0 ? true : undefined;
-  translucent = defaultValue(translucent, defaultTranslucent);
-  translucent = defaultValue(options.translucent, translucent);
+  translucent = translucent ?? defaultTranslucent;
+  translucent = options.translucent ?? translucent;
 
   if (defined(translucent)) {
     if (typeof translucent === "function") {
@@ -1185,7 +1179,7 @@ function createSubMaterials(material) {
 // If excludePeriod is true, do not accept tokens that are preceded by periods.
 // http://stackoverflow.com/questions/641407/javascript-negative-lookbehind-equivalent
 function replaceToken(material, token, newToken, excludePeriod) {
-  excludePeriod = defaultValue(excludePeriod, true);
+  excludePeriod = excludePeriod ?? true;
   let count = 0;
   const suffixChars = "([\\w])?";
   const prefixChars = `([\\w${excludePeriod ? "." : ""}])?`;

package/Source/Scene/MaterialAppearance.js

@@ -1,4 +1,4 @@
-import defaultValue from "../Core/defaultValue.js";
+import Frozen from "../Core/Frozen.js";
 import defined from "../Core/defined.js";
 import VertexFormat from "../Core/VertexFormat.js";
 import AllMaterialAppearanceFS from "../Shaders/Appearances/AllMaterialAppearanceFS.js";
@@ -47,14 +47,12 @@ import Material from "./Material.js";
      * });
      */
 function MaterialAppearance(options) {
-  options = defaultValue(options, defaultValue.EMPTY_OBJECT);
+  options = options ?? Frozen.EMPTY_OBJECT;
 
-  const translucent = defaultValue(options.translucent, true);
-  const closed = defaultValue(options.closed, false);
-  const materialSupport = defaultValue(
-    options.materialSupport,
-    MaterialAppearance.MaterialSupport.TEXTURED,
-  );
+  const translucent = options.translucent ?? true;
+  const closed = options.closed ?? false;
+  const materialSupport =
+    options.materialSupport ?? MaterialAppearance.MaterialSupport.TEXTURED;
 
   /**
    * The material used to determine the fragment color.  Unlike other {@link MaterialAppearance}
@@ -79,14 +77,10 @@ function MaterialAppearance(options) {
    */
   this.translucent = translucent;
 
-  this._vertexShaderSource = defaultValue(
-    options.vertexShaderSource,
-    materialSupport.vertexShaderSource,
-  );
-  this._fragmentShaderSource = defaultValue(
-    options.fragmentShaderSource,
-    materialSupport.fragmentShaderSource,
-  );
+  this._vertexShaderSource =
+    options.vertexShaderSource ?? materialSupport.vertexShaderSource;
+  this._fragmentShaderSource =
+    options.fragmentShaderSource ?? materialSupport.fragmentShaderSource;
   this._renderState = Appearance.getDefaultRenderState(
     translucent,
     closed,
@@ -98,8 +92,8 @@ function MaterialAppearance(options) {
 
   this._materialSupport = materialSupport;
   this._vertexFormat = materialSupport.vertexFormat;
-  this._flat = defaultValue(options.flat, false);
-  this._faceForward = defaultValue(options.faceForward, !closed);
+  this._flat = options.flat ?? false;
+  this._faceForward = options.faceForward ?? !closed;
 }
 
 Object.defineProperties(MaterialAppearance.prototype, {

package/Source/Scene/Megatexture.js

@@ -2,7 +2,6 @@ import Cartesian2 from "../Core/Cartesian2.js";
 import Cartesian3 from "../Core/Cartesian3.js";
 import ComponentDatatype from "../Core/ComponentDatatype.js";
 import ContextLimits from "../Renderer/ContextLimits.js";
-import defaultValue from "../Core/defaultValue.js";
 import defined from "../Core/defined.js";
 import destroyObject from "../Core/destroyObject.js";
 import DeveloperError from "../Core/DeveloperError.js";
@@ -21,11 +20,11 @@ import TextureWrap from "../Renderer/TextureWrap.js";
  * @alias Megatexture
  * @constructor
  *
- * @param {Context} context
- * @param {Cartesian3} dimensions
- * @param {number} channelCount
- * @param {MetadataComponentType} componentType
- * @param {number} [textureMemoryByteLength]
+ * @param {Context} context The context in which to create GPU resources.
+ * @param {Cartesian3} dimensions The number of voxels in each dimension of the tile.
+ * @param {number} channelCount The number of channels in the metadata.
+ * @param {MetadataComponentType} componentType The component type of the metadata.
+ * @param {number} [availableTextureMemoryBytes=134217728] An upper limit on the texture memory size in bytes.
  *
  * @private
  */
@@ -34,59 +33,35 @@ function Megatexture(
   dimensions,
   channelCount,
   componentType,
-  textureMemoryByteLength,
+  availableTextureMemoryBytes,
 ) {
+  const maximumTextureMemoryByteLength = 512 * 1024 * 1024;
+  availableTextureMemoryBytes = Math.min(
+    availableTextureMemoryBytes ?? 128 * 1024 * 1024,
+    maximumTextureMemoryByteLength,
+  );
+
   // TODO there are a lot of texture packing rules, see https://github.com/CesiumGS/cesium/issues/9572
   // Unsigned short textures not allowed in webgl 1, so treat as float
   if (componentType === MetadataComponentType.UNSIGNED_SHORT) {
     componentType = MetadataComponentType.FLOAT32;
   }
 
-  const supportsFloatingPointTexture = context.floatingPointTexture;
   if (
     componentType === MetadataComponentType.FLOAT32 &&
-    !supportsFloatingPointTexture
+    !context.floatingPointTexture
   ) {
     throw new RuntimeError("Floating point texture not supported");
   }
 
-  // TODO support more
-  let pixelType;
-  if (
-    componentType === MetadataComponentType.FLOAT32 ||
-    componentType === MetadataComponentType.FLOAT64
-  ) {
-    pixelType = PixelDatatype.FLOAT;
-  } else if (componentType === MetadataComponentType.UINT8) {
-    pixelType = PixelDatatype.UNSIGNED_BYTE;
-  }
-
-  let pixelFormat;
-  if (channelCount === 1) {
-    pixelFormat = context.webgl2 ? PixelFormat.RED : PixelFormat.LUMINANCE;
-  } else if (channelCount === 2) {
-    pixelFormat = context.webgl2 ? PixelFormat.RG : PixelFormat.LUMINANCE_ALPHA;
-  } else if (channelCount === 3) {
-    pixelFormat = PixelFormat.RGB;
-  } else if (channelCount === 4) {
-    pixelFormat = PixelFormat.RGBA;
-  }
-
-  const maximumTextureMemoryByteLength = 512 * 1024 * 1024;
-  const defaultTextureMemoryByteLength = 128 * 1024 * 1024;
-  textureMemoryByteLength = Math.min(
-    defaultValue(textureMemoryByteLength, defaultTextureMemoryByteLength),
-    maximumTextureMemoryByteLength,
-  );
-  const maximumTextureDimensionContext = ContextLimits.maximumTextureSize;
+  const pixelDataType = getPixelDataType(componentType);
+  const pixelFormat = getPixelFormat(channelCount, context.webgl2);
   const componentTypeByteLength =
     MetadataComponentType.getSizeInBytes(componentType);
-  const texelCount = Math.floor(
-    textureMemoryByteLength / (channelCount * componentTypeByteLength),
-  );
-  const textureDimension = Math.min(
-    maximumTextureDimensionContext,
-    CesiumMath.previousPowerOfTwo(Math.floor(Math.sqrt(texelCount))),
+  const textureDimension = getTextureDimension(
+    availableTextureMemoryBytes,
+    channelCount,
+    componentTypeByteLength,
   );
 
   const sliceCountPerRegionX = Math.ceil(Math.sqrt(dimensions.x));
@@ -116,6 +91,13 @@ function Megatexture(
    */
   this.componentType = componentType;
 
+  /**
+   * @type {number}
+   * @readonly
+   */
+  this.textureMemoryByteLength =
+    componentTypeByteLength * channelCount * textureDimension ** 2;
+
   /**
    * @type {Cartesian3}
    * @readonly
@@ -190,7 +172,7 @@ function Megatexture(
   this.texture = new Texture({
     context: context,
     pixelFormat: pixelFormat,
-    pixelDatatype: pixelType,
+    pixelDatatype: pixelDataType,
     flipY: false,
     width: textureDimension,
     height: textureDimension,
@@ -249,6 +231,73 @@ function Megatexture(
   this.occupiedCount = 0;
 }
 
+/**
+ * Get the pixel data type to use in a megatexture.
+ * TODO support more
+ *
+ * @param {MetadataComponentType} componentType The component type of the metadata.
+ * @returns {PixelDatatype} The pixel datatype to use for a megatexture.
+ *
+ * @private
+ */
+function getPixelDataType(componentType) {
+  if (
+    componentType === MetadataComponentType.FLOAT32 ||
+    componentType === MetadataComponentType.FLOAT64
+  ) {
+    return PixelDatatype.FLOAT;
+  } else if (componentType === MetadataComponentType.UINT8) {
+    return PixelDatatype.UNSIGNED_BYTE;
+  }
+}
+
+/**
+ * Get the pixel format to use for a megatexture.
+ *
+ * @param {number} channelCount The number of channels in the metadata. Must be 1 to 4.
+ * @param {boolean} webgl2 true if the context is using webgl2
+ * @returns {PixelFormat} The pixel format to use for a megatexture.
+ *
+ * @private
+ */
+function getPixelFormat(channelCount, webgl2) {
+  if (channelCount === 1) {
+    return webgl2 ? PixelFormat.RED : PixelFormat.LUMINANCE;
+  } else if (channelCount === 2) {
+    return webgl2 ? PixelFormat.RG : PixelFormat.LUMINANCE_ALPHA;
+  } else if (channelCount === 3) {
+    return PixelFormat.RGB;
+  } else if (channelCount === 4) {
+    return PixelFormat.RGBA;
+  }
+}
+
+/**
+ * Compute the largest size of a square texture that will fit in the available memory.
+ *
+ * @param {number} availableTextureMemoryBytes An upper limit on the texture memory size.
+ * @param {number} channelCount The number of metadata channels per texel.
+ * @param {number} componentByteLength The byte length of each component of the metadata.
+ * @returns {number} The dimension of the square texture to use for the megatexture.
+ *
+ * @private
+ */
+function getTextureDimension(
+  availableTextureMemoryBytes,
+  channelCount,
+  componentByteLength,
+) {
+  // Compute how many texels will fit in the available memory
+  const texelCount = Math.floor(
+    availableTextureMemoryBytes / (channelCount * componentByteLength),
+  );
+  // Return the largest power of two texture size that will fit in memory
+  return Math.min(
+    ContextLimits.maximumTextureSize,
+    CesiumMath.previousPowerOfTwo(Math.floor(Math.sqrt(texelCount))),
+  );
+}
+
 /**
  * @alias MegatextureNode
  * @constructor
@@ -275,8 +324,9 @@ function MegatextureNode(index) {
 }
 
 /**
- * @param {Array} data
- * @returns {number}
+ * Add an array of tile metadata to the megatexture.
+ * @param {Array} data The data to be added.
+ * @returns {number} The index of the tile's location in the megatexture.
  */
 Megatexture.prototype.add = function (data) {
   if (this.isFull()) {
@@ -339,10 +389,10 @@ Megatexture.prototype.isFull = function () {
 };
 
 /**
- * @param {number} tileCount
- * @param {Cartesian3} dimensions
- * @param {number} channelCount number of channels in the metadata. Must be 1 to 4.
- * @param {MetadataComponentType} componentType
+ * @param {number} tileCount The total number of tiles in the tileset.
+ * @param {Cartesian3} dimensions The number of voxels in each dimension of the tile.
+ * @param {number} channelCount The number of channels in the metadata.
+ * @param {MetadataComponentType} componentType The type of one channel of the metadata.
  * @returns {number}
  */
 Megatexture.getApproximateTextureMemoryByteLength = function (
@@ -390,55 +440,52 @@ Megatexture.getApproximateTextureMemoryByteLength = function (
 };
 
 /**
- * @param {number} index
- * @param {Float32Array|Uint16Array|Uint8Array} data
+ * Write an array of tile metadata to the megatexture.
+ * @param {number} index The index of the tile's location in the megatexture.
+ * @param {Float32Array|Uint16Array|Uint8Array} data The data to be written.
  */
 Megatexture.prototype.writeDataToTexture = function (index, data) {
   // Unsigned short textures not allowed in webgl 1, so treat as float
   const tileData =
     data.constructor === Uint16Array ? new Float32Array(data) : data;
 
-  const voxelDimensionsPerTile = this.voxelCountPerTile;
-  const sliceDimensionsPerRegion = this.sliceCountPerRegion;
-  const voxelDimensionsPerRegion = this.voxelCountPerRegion;
-  const channelCount = this.channelCount;
-
-  const tileVoxelData = this.tileVoxelDataTemp;
-  for (let z = 0; z < voxelDimensionsPerTile.z; z++) {
-    const sliceVoxelOffsetX =
-      (z % sliceDimensionsPerRegion.x) * voxelDimensionsPerTile.x;
+  const {
+    tileVoxelDataTemp,
+    voxelCountPerTile,
+    sliceCountPerRegion,
+    voxelCountPerRegion,
+    channelCount,
+    regionCountPerMegatexture,
+  } = this;
+
+  for (let z = 0; z < voxelCountPerTile.z; z++) {
+    const sliceVoxelOffsetX = (z % sliceCountPerRegion.x) * voxelCountPerTile.x;
     const sliceVoxelOffsetY =
-      Math.floor(z / sliceDimensionsPerRegion.x) * voxelDimensionsPerTile.y;
-    for (let y = 0; y < voxelDimensionsPerTile.y; y++) {
-      for (let x = 0; x < voxelDimensionsPerTile.x; x++) {
-        const readIndex =
-          z * voxelDimensionsPerTile.y * voxelDimensionsPerTile.x +
-          y * voxelDimensionsPerTile.x +
-          x;
-        const writeIndex =
-          (sliceVoxelOffsetY + y) * voxelDimensionsPerRegion.x +
-          (sliceVoxelOffsetX + x);
+      Math.floor(z / sliceCountPerRegion.x) * voxelCountPerTile.y;
+    for (let y = 0; y < voxelCountPerTile.y; y++) {
+      const readOffset = getReadOffset(voxelCountPerTile, y, z);
+      const writeOffset =
+        (sliceVoxelOffsetY + y) * voxelCountPerRegion.x + sliceVoxelOffsetX;
+      for (let x = 0; x < voxelCountPerTile.x; x++) {
+        const readIndex = readOffset + x;
+        const writeIndex = writeOffset + x;
         for (let c = 0; c < channelCount; c++) {
-          tileVoxelData[writeIndex * channelCount + c] =
+          tileVoxelDataTemp[writeIndex * channelCount + c] =
             tileData[readIndex * channelCount + c];
         }
       }
     }
   }
 
-  const regionDimensionsPerMegatexture = this.regionCountPerMegatexture;
-  const voxelWidth = voxelDimensionsPerRegion.x;
-  const voxelHeight = voxelDimensionsPerRegion.y;
   const voxelOffsetX =
-    (index % regionDimensionsPerMegatexture.x) * voxelDimensionsPerRegion.x;
+    (index % regionCountPerMegatexture.x) * voxelCountPerRegion.x;
   const voxelOffsetY =
-    Math.floor(index / regionDimensionsPerMegatexture.x) *
-    voxelDimensionsPerRegion.y;
+    Math.floor(index / regionCountPerMegatexture.x) * voxelCountPerRegion.y;
 
   const source = {
-    arrayBufferView: tileVoxelData,
-    width: voxelWidth,
-    height: voxelHeight,
+    arrayBufferView: tileVoxelDataTemp,
+    width: voxelCountPerRegion.x,
+    height: voxelCountPerRegion.y,
   };
 
   const copyOptions = {
@@ -450,6 +497,22 @@ Megatexture.prototype.writeDataToTexture = function (index, data) {
   this.texture.copyFrom(copyOptions);
 };
 
+/**
+ * Get the offset into the data array for a given row of contiguous voxel data.
+ *
+ * @param {Cartesian3} dimensions The number of voxels in each dimension of the tile.
+ * @param {number} y The y index of the voxel row
+ * @param {number} z The z index of the voxel row
+ * @returns {number} The offset into the data array
+ * @private
+ */
+function getReadOffset(dimensions, y, z) {
+  const voxelsPerInputSlice = dimensions.y * dimensions.x;
+  const sliceIndex = z;
+  const rowIndex = y;
+  return sliceIndex * voxelsPerInputSlice + rowIndex * dimensions.x;
+}
+
 /**
  * Returns true if this object was destroyed; otherwise, false.
  * <br /><br />

package/Source/Scene/MetadataClass.js

@@ -1,6 +1,6 @@
 import Check from "../Core/Check.js";
 import clone from "../Core/clone.js";
-import defaultValue from "../Core/defaultValue.js";
+import Frozen from "../Core/Frozen.js";
 import defined from "../Core/defined.js";
 import MetadataClassProperty from "./MetadataClassProperty.js";
 
@@ -24,14 +24,14 @@ import MetadataClassProperty from "./MetadataClassProperty.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 MetadataClass(options) {
-  options = defaultValue(options, defaultValue.EMPTY_OBJECT);
+  options = options ?? Frozen.EMPTY_OBJECT;
   const id = options.id;
 
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.string("options.id", id);
   //>>includeEnd('debug');
 
-  const properties = defaultValue(options.properties, {});
+  const properties = options.properties ?? {};
   const propertiesBySemantic = {};
   for (const propertyId in properties) {
     if (properties.hasOwnProperty(propertyId)) {
@@ -65,7 +65,7 @@ function MetadataClass(options) {
  * @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.
  */
 MetadataClass.fromJson = function (options) {
-  options = defaultValue(options, defaultValue.EMPTY_OBJECT);
+  options = options ?? Frozen.EMPTY_OBJECT;
   const id = options.id;
   const classDefinition = options.class;
 

package/Source/Scene/MetadataClassProperty.js

@@ -3,7 +3,7 @@ import Cartesian3 from "../Core/Cartesian3.js";
 import Cartesian4 from "../Core/Cartesian4.js";
 import Check from "../Core/Check.js";
 import clone from "../Core/clone.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 Matrix2 from "../Core/Matrix2.js";
@@ -45,7 +45,7 @@ import MetadataComponentType from "./MetadataComponentType.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 MetadataClassProperty(options) {
-  options = defaultValue(options, defaultValue.EMPTY_OBJECT);
+  options = options ?? Frozen.EMPTY_OBJECT;
   const id = options.id;
   const type = options.type;
 
@@ -60,7 +60,7 @@ function MetadataClassProperty(options) {
   const normalized =
     defined(componentType) &&
     MetadataComponentType.isIntegerType(componentType) &&
-    defaultValue(options.normalized, false);
+    (options.normalized ?? false);
 
   // Basic information about this property
   this._id = id;
@@ -78,11 +78,8 @@ function MetadataClassProperty(options) {
   this._valueType = defined(enumType) ? enumType.valueType : componentType;
 
   // Details about arrays
-  this._isArray = defaultValue(options.isArray, false);
-  this._isVariableLengthArray = defaultValue(
-    options.isVariableLengthArray,
-    false,
-  );
+  this._isArray = options.isArray ?? false;
+  this._isVariableLengthArray = options.isVariableLengthArray ?? false;
   this._arrayLength = options.arrayLength;
 
   // min and max allowed values
@@ -115,7 +112,7 @@ function MetadataClassProperty(options) {
   // For vector and array types, this is stored as an array of values.
   this._default = clone(options.default, true);
 
-  this._required = defaultValue(options.required, true);
+  this._required = options.required ?? true;
 
   // extras and extensions
   this._extras = clone(options.extras, true);
@@ -136,7 +133,7 @@ function MetadataClassProperty(options) {
  * @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.
  */
 MetadataClassProperty.fromJson = function (options) {
-  options = defaultValue(options, defaultValue.EMPTY_OBJECT);
+  options = options ?? Frozen.EMPTY_OBJECT;
   const id = options.id;
   const property = options.property;
 
@@ -164,7 +161,7 @@ MetadataClassProperty.fromJson = function (options) {
   } else if (isLegacyExtension) {
     required = defined(property.optional) ? !property.optional : true;
   } else {
-    required = defaultValue(property.required, false);
+    required = property.required ?? false;
   }
 
   return new MetadataClassProperty({
@@ -790,7 +787,7 @@ MetadataClassProperty.prototype.expandConstant = function (
   constant,
   enableNestedArrays,
 ) {
-  enableNestedArrays = defaultValue(enableNestedArrays, false);
+  enableNestedArrays = enableNestedArrays ?? false;
   const isArray = this._isArray;
   const arrayLength = this._arrayLength;
   const componentCount = MetadataType.getComponentCount(this._type);
@@ -881,7 +878,7 @@ MetadataClassProperty.prototype.unpackVectorAndMatrixTypes = function (
   value,
   enableNestedArrays,
 ) {
-  enableNestedArrays = defaultValue(enableNestedArrays, false);
+  enableNestedArrays = enableNestedArrays ?? false;
   const MathType = MetadataType.getMathType(this._type);
   const isArray = this._isArray;
   const componentCount = MetadataType.getComponentCount(this._type);
@@ -920,7 +917,7 @@ MetadataClassProperty.prototype.packVectorAndMatrixTypes = function (
   value,
   enableNestedArrays,
 ) {
-  enableNestedArrays = defaultValue(enableNestedArrays, false);
+  enableNestedArrays = enableNestedArrays ?? false;
   const MathType = MetadataType.getMathType(this._type);
   const isArray = this._isArray;
   const componentCount = MetadataType.getComponentCount(this._type);