@cesium/engine 21.0.1 → 22.1.0

package/Source/Core/CesiumTerrainProvider.js

@@ -39,7 +39,7 @@ function LayerInformation(layer) {
 }
 
 /**
- * @typedef {Object} CesiumTerrainProvider.ConstructorOptions
+ * @typedef {object} CesiumTerrainProvider.ConstructorOptions
  *
  * Initialization options for the CesiumTerrainProvider constructor
  *
@@ -1198,7 +1198,7 @@ CesiumTerrainProvider.fromIonAssetId = async function (assetId, options) {
  * <li> {@link https://github.com/AnalyticalGraphicsInc/cesium/wiki/heightmap-1.0 Height Map} </li>
  * </ul>
  *
- * @param {Resource|String|Promise<Resource>|Promise<String>} url The URL of the Cesium terrain server.
+ * @param {Resource|string|Promise<Resource>|Promise<string>} url The URL of the Cesium terrain server.
  * @param {CesiumTerrainProvider.ConstructorOptions} [options] An object describing initialization options.
  * @returns {Promise<CesiumTerrainProvider>}
  *

package/Source/Core/Color.js

@@ -679,6 +679,23 @@ Color.prototype.toBytes = function (result) {
   return result;
 };
 
+/**
+ * Converts RGBA values in bytes to a single numeric unsigned 32-bit RGBA value, using the endianness
+ * of the system.
+ *
+ * @returns {number} A single numeric unsigned 32-bit RGBA value.
+ *
+ * @see Color.toRgba
+ */
+Color.bytesToRgba = function (red, green, blue, alpha) {
+  // scratchUint32Array and scratchUint8Array share an underlying array buffer
+  scratchUint8Array[0] = red;
+  scratchUint8Array[1] = green;
+  scratchUint8Array[2] = blue;
+  scratchUint8Array[3] = alpha;
+  return scratchUint32Array[0];
+};
+
 /**
  * Converts this color to a single numeric unsigned 32-bit RGBA value, using the endianness
  * of the system.
@@ -692,12 +709,12 @@ Color.prototype.toBytes = function (result) {
  * @see Color.fromRgba
  */
 Color.prototype.toRgba = function () {
-  // scratchUint32Array and scratchUint8Array share an underlying array buffer
-  scratchUint8Array[0] = Color.floatToByte(this.red);
-  scratchUint8Array[1] = Color.floatToByte(this.green);
-  scratchUint8Array[2] = Color.floatToByte(this.blue);
-  scratchUint8Array[3] = Color.floatToByte(this.alpha);
-  return scratchUint32Array[0];
+  return Color.bytesToRgba(
+    Color.floatToByte(this.red),
+    Color.floatToByte(this.green),
+    Color.floatToByte(this.blue),
+    Color.floatToByte(this.alpha),
+  );
 };
 
 /**

package/Source/Core/EllipsoidalOccluder.js

@@ -247,7 +247,7 @@ EllipsoidalOccluder.prototype.computeHorizonCullingPointPossiblyUnderEllipsoid =
  *                     A reasonable direction to use is the direction from the center of the ellipsoid to
  *                     the center of the bounding sphere computed from the positions.  The direction need not
  *                     be normalized.
- * @param {number[]} vertices  The vertices from which to compute the horizon culling point.  The positions
+ * @param {number[]|Float32Array|Float64Array} vertices  The vertices from which to compute the horizon culling point. The positions
  *                   must be expressed in a reference frame centered at the ellipsoid and aligned with the
  *                   ellipsoid's axes.
  * @param {number} [stride=3]
@@ -277,7 +277,7 @@ EllipsoidalOccluder.prototype.computeHorizonCullingPointFromVertices =
  *                     A reasonable direction to use is the direction from the center of the ellipsoid to
  *                     the center of the bounding sphere computed from the positions.  The direction need not
  *                     be normalized.
- * @param {number[]} vertices  The vertices from which to compute the horizon culling point.  The positions
+ * @param {number[]|Float32Array|Float64Array} vertices  The vertices from which to compute the horizon culling point.  The positions
  *                   must be expressed in a reference frame centered at the ellipsoid and aligned with the
  *                   ellipsoid's axes.
  * @param {number} [stride=3]

package/Source/Core/FeatureDetection.js

@@ -282,12 +282,10 @@ if (typeof ArrayBuffer !== "undefined") {
   }
 
   if (typeof BigInt64Array !== "undefined") {
-    // eslint-disable-next-line no-undef
     typedArrayTypes.push(BigInt64Array);
   }
 
   if (typeof BigUint64Array !== "undefined") {
-    // eslint-disable-next-line no-undef
     typedArrayTypes.push(BigUint64Array);
   }
 }

package/Source/Core/GoogleEarthEnterpriseMetadata.js

@@ -140,7 +140,7 @@ Object.defineProperties(GoogleEarthEnterpriseMetadata.prototype, {
  * Creates a metadata object using the Google Earth Enterprise REST API. This is used by the GoogleEarthEnterpriseImageryProvider
  * and GoogleEarthEnterpriseTerrainProvider to share metadata requests.
  *
- * @param {Resource|String} resourceOrUrl The url of the Google Earth Enterprise server hosting the imagery.
+ * @param {Resource|string} resourceOrUrl The url of the Google Earth Enterprise server hosting the imagery.
  *
  * @returns {Promise<GoogleEarthEnterpriseMetadata>} A promise which resolves to the created GoogleEarthEnterpriseMetadata instance/
  */

package/Source/Core/GoogleEarthEnterpriseTerrainData.js

@@ -210,6 +210,7 @@ GoogleEarthEnterpriseTerrainData.prototype.createMesh = function (options) {
       result.vertexCountWithoutSkirts,
       result.minimumHeight,
       result.maximumHeight,
+      rectangleScratch,
       BoundingSphere.clone(result.boundingSphere3D),
       Cartesian3.clone(result.occludeePointInScaledSpace),
       result.numberOfAttributes,
@@ -380,7 +381,7 @@ GoogleEarthEnterpriseTerrainData.prototype.upsample = function (
 
 /**
  * Determines if a given child tile is available, based on the
- * {@link HeightmapTerrainData.childTileMask}.  The given child tile coordinates are assumed
+ * {@link GoogleEarthEnterpriseTerrainData.childTileMask}.  The given child tile coordinates are assumed
  * to be one of the four children of this tile.  If non-child tile coordinates are
  * given, the availability of the southeast child tile is returned.
  *

package/Source/Core/GoogleEarthEnterpriseTerrainProvider.js

@@ -65,7 +65,7 @@ TerrainCache.prototype.tidy = function () {
 };
 
 /**
- * @typedef {Object} GoogleEarthEnterpriseTerrainProvider.ConstructorOptions
+ * @typedef {object} GoogleEarthEnterpriseTerrainProvider.ConstructorOptions
  *
  * Initialization options for GoogleEarthEnterpriseTerrainProvider constructor
  *

package/Source/Core/HeightmapTerrainData.js

@@ -94,16 +94,12 @@ import TerrainProvider from "./TerrainProvider.js";
  * @see GoogleEarthEnterpriseTerrainData
  */
 function HeightmapTerrainData(options) {
+  options = options ?? Frozen.EMPTY_OBJECT;
+
   //>>includeStart('debug', pragmas.debug);
-  if (!defined(options) || !defined(options.buffer)) {
-    throw new DeveloperError("options.buffer is required.");
-  }
-  if (!defined(options.width)) {
-    throw new DeveloperError("options.width is required.");
-  }
-  if (!defined(options.height)) {
-    throw new DeveloperError("options.height is required.");
-  }
+  Check.typeOf.object("options.buffer", options.buffer);
+  Check.typeOf.number("options.width", options.width);
+  Check.typeOf.number("options.height", options.height);
   //>>includeEnd('debug');
 
   this._buffer = options.buffer;
@@ -158,7 +154,7 @@ Object.defineProperties(HeightmapTerrainData.prototype, {
    * Uint8Array or image where a value of 255 indicates water and a value of 0 indicates land.
    * Values in between 0 and 255 are allowed as well to smoothly blend between land and water.
    * @memberof HeightmapTerrainData.prototype
-   * @type {Uint8Array|HTMLImageElement|HTMLCanvasElement|undefined}
+   * @type {Uint8Array|HTMLImageElement|HTMLCanvasElement|ImageBitmap|undefined}
    */
   waterMask: {
     get: function () {
@@ -287,6 +283,7 @@ HeightmapTerrainData.prototype.createMesh = function (options) {
       vertexCountWithoutSkirts,
       result.minimumHeight,
       result.maximumHeight,
+      rectangle,
       BoundingSphere.clone(result.boundingSphere3D),
       Cartesian3.clone(result.occludeePointInScaledSpace),
       result.numberOfAttributes,
@@ -393,6 +390,7 @@ HeightmapTerrainData.prototype._createMeshSync = function (options) {
     vertexCountWithoutSkirts,
     result.minimumHeight,
     result.maximumHeight,
+    rectangle,
     result.boundingSphere3D,
     result.occludeePointInScaledSpace,
     result.encoding.stride,
@@ -645,18 +643,10 @@ HeightmapTerrainData.prototype.isChildAvailable = function (
   childY,
 ) {
   //>>includeStart('debug', pragmas.debug);
-  if (!defined(thisX)) {
-    throw new DeveloperError("thisX is required.");
-  }
-  if (!defined(thisY)) {
-    throw new DeveloperError("thisY is required.");
-  }
-  if (!defined(childX)) {
-    throw new DeveloperError("childX is required.");
-  }
-  if (!defined(childY)) {
-    throw new DeveloperError("childY is required.");
-  }
+  Check.typeOf.number("thisX", thisX);
+  Check.typeOf.number("thisY", thisY);
+  Check.typeOf.number("childX", childX);
+  Check.typeOf.number("childY", childY);
   //>>includeEnd('debug');
 
   let bitNumber = 2; // northwest child

package/Source/Core/HilbertOrder.js

@@ -38,13 +38,11 @@ HilbertOrder.encode2D = function (level, x, y) {
   let rx,
     ry,
     s,
-    // eslint-disable-next-line no-undef
     index = BigInt(0);
 
   for (s = n / 2; s > 0; s /= 2) {
     rx = (p.x & s) > 0 ? 1 : 0;
     ry = (p.y & s) > 0 ? 1 : 0;
-    // eslint-disable-next-line no-undef
     index += BigInt(((3 * rx) ^ ry) * s * s);
     rotate(n, p, rx, ry);
   }
@@ -67,7 +65,6 @@ HilbertOrder.decode2D = function (level, index) {
   if (level < 1) {
     throw new DeveloperError("Hilbert level cannot be less than 1.");
   }
-  // eslint-disable-next-line no-undef
   if (index < BigInt(0) || index >= BigInt(Math.pow(4, level))) {
     throw new DeveloperError(
       "Hilbert index exceeds valid maximum for given level.",
@@ -83,14 +80,11 @@ HilbertOrder.decode2D = function (level, index) {
   let rx, ry, s, t;
 
   for (s = 1, t = index; s < n; s *= 2) {
-    // eslint-disable-next-line no-undef
     rx = 1 & Number(t / BigInt(2));
-    // eslint-disable-next-line no-undef
     ry = 1 & Number(t ^ BigInt(rx));
     rotate(s, p, rx, ry);
     p.x += s * rx;
     p.y += s * ry;
-    // eslint-disable-next-line no-undef
     t /= BigInt(4);
   }
 

package/Source/Core/ITwinPlatform.js

@@ -114,7 +114,7 @@ ITwinPlatform.apiEndpoint = new Resource({
 });
 
 /**
- * @typedef {Object} ExportRequest
+ * @typedef {object} ExportRequest
  * @private
  * @property {string} iModelId
  * @property {string} changesetId
@@ -122,13 +122,13 @@ ITwinPlatform.apiEndpoint = new Resource({
  */
 
 /**
- * @typedef {Object} Link
+ * @typedef {object} Link
  * @private
  * @property {string} href
  */
 
 /**
- * @typedef {Object} ExportRepresentation
+ * @typedef {object} ExportRepresentation
  * The export objects from get-exports when using return=representation
  * @private
  * @property {string} id Export id
@@ -140,7 +140,7 @@ ITwinPlatform.apiEndpoint = new Resource({
  */
 
 /**
- * @typedef {Object} GetExportsResponse
+ * @typedef {object} GetExportsResponse
  * @private
  * @property {ExportRepresentation[]} exports The list of exports for the current page
  * @property {{self: Link, next: Link | undefined, prev: Link | undefined}} _links Pagination links
@@ -224,14 +224,14 @@ ITwinPlatform.getExports = async function (iModelId, changesetId) {
 };
 
 /**
- * @typedef {Object} RealityDataExtent
+ * @typedef {object} RealityDataExtent
  * @private
  * @property {{latitude: number, longitude: number}} southWest
  * @property {{latitude: number, longitude: number}} northEast
  */
 
 /**
- * @typedef {Object} RealityDataRepresentation
+ * @typedef {object} RealityDataRepresentation
  * @private
  * @property {string} id "95d8dccd-d89e-4287-bb5f-3219acbc71ae",
  * @property {string} displayName "Name of reality data",

package/Source/Core/IntersectionTests.js

@@ -495,6 +495,86 @@ IntersectionTests.rayEllipsoid = function (ray, ellipsoid) {
   return undefined;
 };
 
+const scratchRayIntervalX = new Interval();
+const scratchRayIntervalY = new Interval();
+const scratchRayIntervalZ = new Interval();
+
+/**
+ * Computes the intersection points of a ray with an axis-aligned bounding box. (axis-aligned in the same space as the ray)
+ *
+ * @param {Ray} ray The ray.
+ * @param {AxisAlignedBoundingBox} box The axis-aligned bounding box.
+ * @param {Interval | undefined} result The interval containing scalar points along the ray or undefined if there are no intersections.
+ */
+IntersectionTests.rayAxisAlignedBoundingBox = function (ray, box, result) {
+  //>>includeStart('debug', pragmas.debug);
+  if (!defined(ray)) {
+    throw new DeveloperError("ray is required.");
+  }
+  if (!defined(box)) {
+    throw new DeveloperError("box is required.");
+  }
+  //>>includeEnd('debug');
+
+  if (!defined(result)) {
+    result = new Interval();
+  }
+
+  const tx = rayIntervalAlongAABBAxis(
+    ray.origin.x,
+    ray.direction.x,
+    box.minimum.x,
+    box.maximum.x,
+    scratchRayIntervalX,
+  );
+  const ty = rayIntervalAlongAABBAxis(
+    ray.origin.y,
+    ray.direction.y,
+    box.minimum.y,
+    box.maximum.y,
+    scratchRayIntervalY,
+  );
+  const tz = rayIntervalAlongAABBAxis(
+    ray.origin.z,
+    ray.direction.z,
+    box.minimum.z,
+    box.maximum.z,
+    scratchRayIntervalZ,
+  );
+
+  result.start = tx.start > ty.start ? tx.start : ty.start; //Get Greatest Min
+  result.stop = tx.stop < ty.stop ? tx.stop : ty.stop; //Get Smallest Max
+
+  if (tx.start > ty.stop || ty.start > tx.stop) {
+    return undefined;
+  }
+
+  if (result.start > tz.stop || tz.start > result.stop) {
+    return undefined;
+  }
+
+  if (tz.start > result.start) {
+    result.start = tz.start;
+  }
+  if (tz.stop < result.stop) {
+    result.stop = tz.stop;
+  }
+
+  return result;
+};
+
+function rayIntervalAlongAABBAxis(origin, direction, min, max, result) {
+  result.start = (min - origin) / direction;
+  result.stop = (max - origin) / direction;
+  if (result.stop < result.start) {
+    const tmp = result.stop;
+    result.stop = result.start;
+    result.start = tmp;
+  }
+
+  return result;
+}
+
 function addWithCancellationCheck(left, right, tolerance) {
   const difference = left + right;
   if (

package/Source/Core/Ion.js

@@ -4,7 +4,7 @@ import Resource from "./Resource.js";
 
 let defaultTokenCredit;
 const defaultAccessToken =
-  "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiJjNjI5ZTViNy0wY2FhLTQ0ZDUtYTIzMi0wMWEyMzZkYWYwYWYiLCJpZCI6MjU5LCJpYXQiOjE3NTkzNDcyNDZ9.xyOPig1igKFQvOTaXfTE0KQ7dU7jyn_c3OQPaQ1hEiI";
+  "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiIxYTBmZmMzNy02NzcxLTRiMjUtYTllZS1hZmJjY2RkYjVhY2UiLCJpZCI6MjU5LCJpYXQiOjE3NjQ2MDU5OTB9.Nefln7pgRwDffoCJRJ8aaZn5iQzIPQrboLwKD2-ArDU";
 /**
  * Default settings for accessing the Cesium ion API.
  *

package/Source/Core/IonResource.js

@@ -7,6 +7,14 @@ import Ion from "./Ion.js";
 import Resource from "./Resource.js";
 import RuntimeError from "./RuntimeError.js";
 
+/**
+ * A function that will be invoked when the access token is refreshed.
+ * @callback IonResourceRefreshCallback
+ * @param {IonResource} ionResource The root IonResource being refreshed.
+ * @param {object} endpoint The result of the Cesium ion asset endpoint service. This may be modified in place by the callback.
+ * @private
+ */
+
 /**
  * A {@link Resource} instance that encapsulates Cesium ion asset access.
  * This object is normally not instantiated directly, use {@link IonResource.fromAssetId}.
@@ -16,7 +24,7 @@ import RuntimeError from "./RuntimeError.js";
  * @augments Resource
  *
  * @param {object} endpoint The result of the Cesium ion asset endpoint service.
- * @param {Resource} endpointResource The resource used to retrieve the endpoint.
+ * @param {Resource} endpointResource The original resource used to retrieve the endpoint.
  *
  * @see Ion
  * @see IonImageryProvider
@@ -39,12 +47,6 @@ function IonResource(endpoint, endpointResource) {
       retryAttempts: 1,
       retryCallback: retryCallback,
     };
-  } else if (["GOOGLE_2D_MAPS", "AZURE_MAPS"].includes(externalType)) {
-    options = {
-      url: endpoint.options.url,
-      retryAttempts: 1,
-      retryCallback: retryCallback,
-    };
   } else if (
     externalType === "3DTILES" ||
     externalType === "STK_TERRAIN_SERVER"
@@ -76,6 +78,13 @@ function IonResource(endpoint, endpointResource) {
   this._pendingPromise = undefined;
   this._credits = undefined;
   this._isExternal = isExternal;
+
+  /**
+   * A function that, if defined, will be invoked when the access token is refreshed.
+   * @private
+   * @type {IonResourceRefreshCallback|undefined}
+   */
+  this.refreshCallback = undefined;
 }
 
 if (defined(Object.create)) {
@@ -205,7 +214,7 @@ IonResource.prototype._makeRequest = function (options) {
     return Resource.prototype._makeRequest.call(this, options);
   }
 
-  addClientHeaders(options);
+  options.headers = addClientHeaders(options.headers);
   options.headers.Authorization = `Bearer ${this._ionEndpoint.accessToken}`;
 
   return Resource.prototype._makeRequest.call(this, options);
@@ -239,20 +248,26 @@ IonResource._createEndpointResource = function (assetId, options) {
     };
   }
 
-  addClientHeaders(resourceOptions);
+  resourceOptions.headers = addClientHeaders(resourceOptions.headers);
 
   return server.getDerivedResource(resourceOptions);
 };
 
-function addClientHeaders(options) {
-  if (!defined(options.headers)) {
-    options.headers = {};
-  }
-  options.headers["X-Cesium-Client"] = "CesiumJS";
+/**
+ * Adds CesiumJS client headers to the provided headers object.
+ * @private
+ * @param {object} [headers={}] The headers to modify.
+ * @returns {object} The modified headers.
+ */
+function addClientHeaders(headers = {}) {
+  headers["X-Cesium-Client"] = "CesiumJS";
+
   /* global CESIUM_VERSION */
   if (typeof CESIUM_VERSION !== "undefined") {
-    options.headers["X-Cesium-Client-Version"] = CESIUM_VERSION;
+    headers["X-Cesium-Client-Version"] = CESIUM_VERSION;
   }
+
+  return headers;
 }
 
 function retryCallback(that, error) {
@@ -280,20 +295,13 @@ function retryCallback(that, error) {
     ionRoot._pendingPromise = endpointResource
       .fetchJson()
       .then(function (newEndpoint) {
+        const refreshCallback = that.refreshCallback ?? ionRoot.refreshCallback;
+        if (defined(refreshCallback)) {
+          refreshCallback(ionRoot, newEndpoint);
+        }
+
         // Set the token for root resource so new derived resources automatically pick it up
         ionRoot._ionEndpoint = newEndpoint;
-        // Reset the session token for Google 2D imagery
-        if (newEndpoint.externalType === "GOOGLE_2D_MAPS") {
-          ionRoot.setQueryParameters({
-            session: newEndpoint.options.session,
-            key: newEndpoint.options.key,
-          });
-        }
-        if (newEndpoint.externalType === "AZURE_MAPS") {
-          ionRoot.setQueryParameters({
-            "subscription-key": newEndpoint.options["subscription-key"],
-          });
-        }
         return ionRoot._ionEndpoint;
       })
       .finally(function (newEndpoint) {

package/Source/Core/PixelFormat.js

@@ -464,8 +464,8 @@ PixelFormat.alignmentInBytes = function (pixelFormat, pixelDatatype, width) {
  * @private
  * @param {PixelFormat} pixelFormat The pixel format.
  * @param {PixelDatatype} pixelDatatype The pixel datatype.
- * @param {Number} width The width of the texture.
- * @param {Number} height The height of the texture.
+ * @param {number} width The width of the texture.
+ * @param {number} height The height of the texture.
  * @returns {TypedArray} The typed array.
  */
 PixelFormat.createTypedArray = function (

package/Source/Core/QuantizedMeshTerrainData.js

@@ -92,52 +92,26 @@ import TerrainMesh from "./TerrainMesh.js";
  * @see GoogleEarthEnterpriseTerrainData
  */
 function QuantizedMeshTerrainData(options) {
+  options = options ?? Frozen.EMPTY_OBJECT;
+
   //>>includeStart('debug', pragmas.debug)
-  if (!defined(options) || !defined(options.quantizedVertices)) {
-    throw new DeveloperError("options.quantizedVertices is required.");
-  }
-  if (!defined(options.indices)) {
-    throw new DeveloperError("options.indices is required.");
-  }
-  if (!defined(options.minimumHeight)) {
-    throw new DeveloperError("options.minimumHeight is required.");
-  }
-  if (!defined(options.maximumHeight)) {
-    throw new DeveloperError("options.maximumHeight is required.");
-  }
-  if (!defined(options.maximumHeight)) {
-    throw new DeveloperError("options.maximumHeight is required.");
-  }
-  if (!defined(options.boundingSphere)) {
-    throw new DeveloperError("options.boundingSphere is required.");
-  }
-  if (!defined(options.horizonOcclusionPoint)) {
-    throw new DeveloperError("options.horizonOcclusionPoint is required.");
-  }
-  if (!defined(options.westIndices)) {
-    throw new DeveloperError("options.westIndices is required.");
-  }
-  if (!defined(options.southIndices)) {
-    throw new DeveloperError("options.southIndices is required.");
-  }
-  if (!defined(options.eastIndices)) {
-    throw new DeveloperError("options.eastIndices is required.");
-  }
-  if (!defined(options.northIndices)) {
-    throw new DeveloperError("options.northIndices is required.");
-  }
-  if (!defined(options.westSkirtHeight)) {
-    throw new DeveloperError("options.westSkirtHeight is required.");
-  }
-  if (!defined(options.southSkirtHeight)) {
-    throw new DeveloperError("options.southSkirtHeight is required.");
-  }
-  if (!defined(options.eastSkirtHeight)) {
-    throw new DeveloperError("options.eastSkirtHeight is required.");
-  }
-  if (!defined(options.northSkirtHeight)) {
-    throw new DeveloperError("options.northSkirtHeight is required.");
-  }
+  Check.typeOf.object("options.quantizedVertices", options.quantizedVertices);
+  Check.typeOf.object("options.indices", options.indices);
+  Check.typeOf.number("options.minimumHeight", options.minimumHeight);
+  Check.typeOf.number("options.maximumHeight", options.maximumHeight);
+  Check.typeOf.object("options.boundingSphere", options.boundingSphere);
+  Check.typeOf.object(
+    "options.horizonOcclusionPoint",
+    options.horizonOcclusionPoint,
+  );
+  Check.typeOf.object("options.westIndices", options.westIndices);
+  Check.typeOf.object("options.southIndices", options.southIndices);
+  Check.typeOf.object("options.eastIndices", options.eastIndices);
+  Check.typeOf.object("options.northIndices", options.northIndices);
+  Check.typeOf.number("options.westSkirtHeight", options.westSkirtHeight);
+  Check.typeOf.number("options.southSkirtHeight", options.southSkirtHeight);
+  Check.typeOf.number("options.eastSkirtHeight", options.eastSkirtHeight);
+  Check.typeOf.number("options.northSkirtHeight", options.northSkirtHeight);
   //>>includeEnd('debug');
 
   this._quantizedVertices = options.quantizedVertices;
@@ -375,6 +349,7 @@ QuantizedMeshTerrainData.prototype.createMesh = function (options) {
       vertexCountWithoutSkirts,
       minimumHeight,
       maximumHeight,
+      rectangle,
       boundingSphere,
       occludeePointInScaledSpace,
       stride,
@@ -729,18 +704,10 @@ QuantizedMeshTerrainData.prototype.isChildAvailable = function (
   childY,
 ) {
   //>>includeStart('debug', pragmas.debug);
-  if (!defined(thisX)) {
-    throw new DeveloperError("thisX is required.");
-  }
-  if (!defined(thisY)) {
-    throw new DeveloperError("thisY is required.");
-  }
-  if (!defined(childX)) {
-    throw new DeveloperError("childX is required.");
-  }
-  if (!defined(childY)) {
-    throw new DeveloperError("childY is required.");
-  }
+  Check.typeOf.number("thisX", thisX);
+  Check.typeOf.number("thisY", thisY);
+  Check.typeOf.number("childX", childX);
+  Check.typeOf.number("childY", childY);
   //>>includeEnd('debug');
 
   let bitNumber = 2; // northwest child