@cesium/engine 21.0.1-ion.0 → 22.0.0

package/Source/Core/S2Cell.js

@@ -1,4 +1,3 @@
-/* eslint-disable new-cap */
 import Cartesian3 from "./Cartesian3.js";
 import Cartographic from "./Cartographic.js";
 import Check from "./Check.js";
@@ -209,15 +208,12 @@ S2Cell.isValidId = function (cellId) {
   }
 
   // Check if face bits indicate a valid value, in range [0-5].
-  // eslint-disable-next-line
   if (cellId >> BigInt(S2_POSITION_BITS) > 5) {
     return false;
   }
 
   // Check trailing 1 bit is in one of the even bit positions allowed for the 30 levels, using a bitmask.
-  // eslint-disable-next-line no-undef
   const lowestSetBit = cellId & (~cellId + BigInt(1));
-  // eslint-disable-next-line
   if (!(lowestSetBit & BigInt("0x1555555555555555"))) {
     return false;
   }
@@ -296,14 +292,12 @@ S2Cell.getLevel = function (cellId) {
   //>>includeEnd('debug');
 
   let lsbPosition = 0;
-  // eslint-disable-next-line
   while (cellId !== BigInt(0)) {
-    // eslint-disable-next-line
     if (cellId & BigInt(1)) {
       break;
     }
     lsbPosition++;
-    cellId = cellId >> BigInt(1); // eslint-disable-line
+    cellId = cellId >> BigInt(1);
   }
 
   // We use (>> 1) because there are 2 bits per level.
@@ -329,10 +323,8 @@ S2Cell.prototype.getChild = function (index) {
   //>>includeEnd('debug');
 
   // Shift sentinel bit 2 positions to the right.
-  // eslint-disable-next-line no-undef
   const newLsb = lsb(this._cellId) >> BigInt(2);
   // Insert child index before the sentinel bit.
-  // eslint-disable-next-line no-undef
   const childCellId = this._cellId + BigInt(2 * index + 1 - 4) * newLsb;
   return new S2Cell(childCellId);
 };
@@ -350,10 +342,8 @@ S2Cell.prototype.getParent = function () {
   }
   //>>includeEnd('debug');
   // Shift the sentinel bit 2 positions to the left.
-  // eslint-disable-next-line no-undef
   const newLsb = lsb(this._cellId) << BigInt(2);
   // Erase the left over bits to the right of the sentinel bit.
-  // eslint-disable-next-line no-undef
   return new S2Cell((this._cellId & (~newLsb + BigInt(1))) | newLsb);
 };
 
@@ -455,7 +445,6 @@ S2Cell.fromFacePositionLevel = function (face, position, level) {
   ).join("0");
   const positionSuffixPadding = Array(S2_POSITION_BITS - 2 * level).join("0");
 
-  // eslint-disable-next-line no-undef
   const cellId = BigInt(
     `0b${faceBitString}${positionPrefixPadding}${positionBitString}1${
       // Adding the sentinel bit that always follows the position bits.
@@ -500,7 +489,7 @@ function convertCellIdToFaceSiTi(cellId, level) {
   // that represent the parent cell center.
   const isLeaf = level === 30;
   const shouldCorrect =
-    !isLeaf && (BigInt(i) ^ (cellId >> BigInt(2))) & BigInt(1); // eslint-disable-line
+    !isLeaf && (BigInt(i) ^ (cellId >> BigInt(2))) & BigInt(1);
   const correction = isLeaf ? 1 : shouldCorrect ? 2 : 0;
   const si = (i << 1) + correction;
   const ti = (j << 1) + correction;
@@ -515,7 +504,6 @@ function convertCellIdToFaceIJ(cellId) {
     generateLookupTable();
   }
 
-  // eslint-disable-next-line no-undef
   const face = Number(cellId >> BigInt(S2_POSITION_BITS));
   let bits = face & S2_SWAP_MASK;
   const lookupMask = (1 << S2_LOOKUP_BITS) - 1;
@@ -529,7 +517,7 @@ function convertCellIdToFaceIJ(cellId) {
     const extractMask = (1 << (2 * numberOfBits)) - 1;
     bits +=
       Number(
-        (cellId >> BigInt(k * 2 * S2_LOOKUP_BITS + 1)) & BigInt(extractMask), // eslint-disable-line
+        (cellId >> BigInt(k * 2 * S2_LOOKUP_BITS + 1)) & BigInt(extractMask),
       ) << 2;
 
     bits = S2_LOOKUP_IJ[bits];
@@ -715,7 +703,7 @@ function generateLookupTable() {
  * @private
  */
 function lsb(cellId) {
-  return cellId & (~cellId + BigInt(1)); // eslint-disable-line
+  return cellId & (~cellId + BigInt(1));
 }
 
 /**
@@ -723,7 +711,7 @@ function lsb(cellId) {
  * @private
  */
 function lsbForLevel(level) {
-  return BigInt(1) << BigInt(2 * (S2_MAX_LEVEL - level)); // eslint-disable-line
+  return BigInt(1) << BigInt(2 * (S2_MAX_LEVEL - level));
 }
 
 // Lookup table for getting trailing zero bits.
@@ -740,7 +728,7 @@ const Mod67BitPosition = [
  * @private
  */
 function countTrailingZeroBits(x) {
-  return Mod67BitPosition[(-x & x) % BigInt(67)]; // eslint-disable-line
+  return Mod67BitPosition[(-x & x) % BigInt(67)];
 }
 
 export default S2Cell;

package/Source/Core/TaskProcessor.js

@@ -267,7 +267,7 @@ async function scheduleTask(processor, parameters, transferableObjects) {
  * finished.
  *
  * @param {object} parameters Any input data that will be posted to the worker.
- * @param {Object[]} [transferableObjects] An array of objects contained in parameters that should be
+ * @param {object[]} [transferableObjects] An array of objects contained in parameters that should be
  *                                      transferred to the worker instead of copied.
  * @returns {Promise<object>|undefined} Either a promise that will resolve to the result when available, or undefined
  *                    if there are too many active tasks,

package/Source/Core/TerrainData.js

@@ -10,6 +10,7 @@ import DeveloperError from "./DeveloperError.js";
  * @see HeightmapTerrainData
  * @see QuantizedMeshTerrainData
  * @see GoogleEarthEnterpriseTerrainData
+ * @see Cesium3DTilesTerrainData
  */
 function TerrainData() {
   DeveloperError.throwInstantiationError();
@@ -29,7 +30,7 @@ Object.defineProperties(TerrainData.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 TerrainData.prototype
-   * @type {Uint8Array|HTMLImageElement|HTMLCanvasElement|undefined}
+   * @type {Uint8Array|HTMLImageElement|HTMLCanvasElement|ImageBitmap|undefined}
    */
   waterMask: {
     get: DeveloperError.throwInstantiationError,

package/Source/Core/TerrainEncoding.js

@@ -1,6 +1,7 @@
 import AttributeCompression from "./AttributeCompression.js";
 import Cartesian2 from "./Cartesian2.js";
 import Cartesian3 from "./Cartesian3.js";
+import Check from "./Check.js";
 import ComponentDatatype from "./ComponentDatatype.js";
 import defined from "./defined.js";
 import CesiumMath from "./Math.js";
@@ -24,11 +25,11 @@ const SHIFT_LEFT_12 = Math.pow(2.0, 12.0);
  * @constructor
  *
  * @param {Cartesian3} center The center point of the vertices.
- * @param {AxisAlignedBoundingBox} axisAlignedBoundingBox The bounds of the tile in the east-north-up coordinates at the tiles center.
- * @param {number} minimumHeight The minimum height.
- * @param {number} maximumHeight The maximum height.
- * @param {Matrix4} fromENU The east-north-up to fixed frame matrix at the center of the terrain mesh.
- * @param {boolean} hasVertexNormals If the mesh has vertex normals.
+ * @param {AxisAlignedBoundingBox} [axisAlignedBoundingBox] The bounds of the tile in the east-north-up coordinates at the tiles center.
+ * @param {number} [minimumHeight] The minimum height.
+ * @param {number} [maximumHeight] The maximum height.
+ * @param {Matrix4} [fromENU] The east-north-up to fixed frame matrix at the center of the terrain mesh.
+ * @param {boolean} [hasVertexNormals=false] If the mesh has vertex normals.
  * @param {boolean} [hasWebMercatorT=false] true if the terrain data includes a Web Mercator texture coordinate; otherwise, false.
  * @param {boolean} [hasGeodeticSurfaceNormals=false] true if the terrain data includes geodetic surface normals; otherwise, false.
  * @param {number} [exaggeration=1.0] A scalar used to exaggerate terrain.
@@ -75,32 +76,36 @@ function TerrainEncoding(
       quantization = TerrainQuantization.NONE;
     }
 
-    toENU = Matrix4.inverseTransformation(fromENU, new Matrix4());
-
-    const translation = Cartesian3.negate(minimum, cartesian3Scratch);
-    Matrix4.multiply(
-      Matrix4.fromTranslation(translation, matrix4Scratch),
-      toENU,
-      toENU,
+    // Scale and bias from [0,1] to [ENU min, ENU max]
+    // Also compute the inverse of the scale and bias
+    let st = Matrix4.fromScale(dimensions, matrix4Scratch);
+    st = Matrix4.setTranslation(st, minimum, st);
+
+    let invSt = Matrix4.fromScale(
+      Cartesian3.fromElements(
+        1.0 / dimensions.x,
+        1.0 / dimensions.y,
+        1.0 / dimensions.z,
+        cartesian3Scratch,
+      ),
+      matrix4Scratch2,
+    );
+    invSt = Matrix4.multiplyByTranslation(
+      invSt,
+      Cartesian3.negate(minimum, cartesian3Scratch),
+      invSt,
     );
 
-    const scale = cartesian3Scratch;
-    scale.x = 1.0 / dimensions.x;
-    scale.y = 1.0 / dimensions.y;
-    scale.z = 1.0 / dimensions.z;
-    Matrix4.multiply(Matrix4.fromScale(scale, matrix4Scratch), toENU, toENU);
-
-    matrix = Matrix4.clone(fromENU);
-    Matrix4.setTranslation(matrix, Cartesian3.ZERO, matrix);
-
-    fromENU = Matrix4.clone(fromENU, new Matrix4());
+    matrix = Matrix4.clone(fromENU, new Matrix4());
+    let rtcOffset = Matrix4.getTranslation(fromENU, cartesian3Scratch);
+    rtcOffset = Cartesian3.subtract(rtcOffset, center, cartesian3Scratch);
+    matrix = Matrix4.setTranslation(matrix, rtcOffset, matrix);
+    matrix = Matrix4.multiply(matrix, st, matrix);
 
-    const translationMatrix = Matrix4.fromTranslation(minimum, matrix4Scratch);
-    const scaleMatrix = Matrix4.fromScale(dimensions, matrix4Scratch2);
-    const st = Matrix4.multiply(translationMatrix, scaleMatrix, matrix4Scratch);
+    toENU = Matrix4.inverseTransformation(fromENU, new Matrix4());
+    toENU = Matrix4.multiply(invSt, toENU, toENU);
 
-    Matrix4.multiply(fromENU, st, fromENU);
-    Matrix4.multiply(matrix, st, matrix);
+    fromENU = Matrix4.multiply(fromENU, st, new Matrix4());
   }
 
   /**
@@ -111,13 +116,13 @@ function TerrainEncoding(
 
   /**
    * The minimum height of the tile including the skirts.
-   * @type {number}
+   * @type {number|undefined}
    */
   this.minimumHeight = minimumHeight;
 
   /**
    * The maximum height of the tile.
-   * @type {number}
+   * @type {number|undefined}
    */
   this.maximumHeight = maximumHeight;
 
@@ -130,19 +135,19 @@ function TerrainEncoding(
   /**
    * A matrix that takes a vertex from the tile, transforms it to east-north-up at the center and scales
    * it so each component is in the [0, 1] range.
-   * @type {Matrix4}
+   * @type {Matrix4|undefined}
    */
   this.toScaledENU = toENU;
 
   /**
    * A matrix that restores a vertex transformed with toScaledENU back to the earth fixed reference frame
-   * @type {Matrix4}
+   * @type {Matrix4|undefined}
    */
   this.fromScaledENU = fromENU;
 
   /**
    * The matrix used to decompress the terrain vertices in the shader for RTE rendering.
-   * @type {Matrix4}
+   * @type {Matrix4|undefined}
    */
   this.matrix = matrix;
 
@@ -150,7 +155,7 @@ function TerrainEncoding(
    * The terrain mesh contains normals.
    * @type {boolean}
    */
-  this.hasVertexNormals = hasVertexNormals;
+  this.hasVertexNormals = hasVertexNormals ?? false;
 
   /**
    * The terrain mesh contains a vertical texture coordinate following the Web Mercator projection.
@@ -188,6 +193,20 @@ function TerrainEncoding(
   this._calculateStrideAndOffsets();
 }
 
+/**
+ * Encode information about the terrain at a given position into the vertex buffer.
+ * Position, texture coordinates, height, and (optionally) normal, projection information,
+ * and geodetic surface normal are all packed into the same buffer.
+ *
+ * @param {Float32Array} vertexBuffer The buffer to write to.
+ * @param {number} bufferIndex The index into the buffer to start writing at.
+ * @param {Cartesian3} position The position of the vertex.
+ * @param {Cartesian2} uv The texture coordinates of the vertex.
+ * @param {number} height The height of the vertex.
+ * @param {Cartesian2} [normalToPack] The normal vector of the vertex.
+ * @param {number} [webMercatorT] The Web Mercator texture coordinate of the vertex.
+ * @param {Cartesian3} [geodeticSurfaceNormal] The geodetic surface normal of the vertex.
+ */
 TerrainEncoding.prototype.encode = function (
   vertexBuffer,
   bufferIndex,
@@ -198,6 +217,14 @@ TerrainEncoding.prototype.encode = function (
   webMercatorT,
   geodeticSurfaceNormal,
 ) {
+  //>>includeStart('debug', pragmas.debug);
+  Check.typeOf.object("vertexBuffer", vertexBuffer);
+  Check.typeOf.number("bufferIndex", bufferIndex);
+  Check.typeOf.object("position", position);
+  Check.typeOf.object("uv", uv);
+  Check.typeOf.number("height", height);
+  //>>includeEnd('debug');
+
   const u = uv.x;
   const v = uv.y;
 
@@ -238,11 +265,9 @@ TerrainEncoding.prototype.encode = function (
       vertexBuffer[bufferIndex++] = compressed3;
     }
   } else {
-    Cartesian3.subtract(position, this.center, cartesian3Scratch);
-
-    vertexBuffer[bufferIndex++] = cartesian3Scratch.x;
-    vertexBuffer[bufferIndex++] = cartesian3Scratch.y;
-    vertexBuffer[bufferIndex++] = cartesian3Scratch.z;
+    vertexBuffer[bufferIndex++] = position.x - this.center.x;
+    vertexBuffer[bufferIndex++] = position.y - this.center.y;
+    vertexBuffer[bufferIndex++] = position.z - this.center.z;
     vertexBuffer[bufferIndex++] = height;
     vertexBuffer[bufferIndex++] = u;
     vertexBuffer[bufferIndex++] = v;
@@ -269,11 +294,25 @@ TerrainEncoding.prototype.encode = function (
 const scratchPosition = new Cartesian3();
 const scratchGeodeticSurfaceNormal = new Cartesian3();
 
+/**
+ * Add geodetic surface normals to a terrain vertex buffer.
+ * The new buffer will be larger than the old buffer.
+ *
+ * @param {Float32Array} oldBuffer The buffer without geodetic surface normals.
+ * @param {Float32Array} newBuffer The buffer with geodetic surface normals.
+ * @param {Ellipsoid} ellipsoid The ellipsoid to use to compute the geodetic surface normals.
+ */
 TerrainEncoding.prototype.addGeodeticSurfaceNormals = function (
   oldBuffer,
   newBuffer,
   ellipsoid,
 ) {
+  //>>includeStart('debug', pragmas.debug);
+  Check.typeOf.object("oldBuffer", oldBuffer);
+  Check.typeOf.object("newBuffer", newBuffer);
+  Check.typeOf.object("ellipsoid", ellipsoid);
+  //>>includeEnd('debug');
+
   if (this.hasGeodeticSurfaceNormals) {
     return;
   }
@@ -303,10 +342,21 @@ TerrainEncoding.prototype.addGeodeticSurfaceNormals = function (
   }
 };
 
+/**
+ * Remove geodetic surface normals from a terrain vertex buffer.
+ *
+ * @param {Float32Array} oldBuffer The buffer with geodetic surface normals.
+ * @param {Float32Array} newBuffer The buffer without geodetic surface normals.
+ */
 TerrainEncoding.prototype.removeGeodeticSurfaceNormals = function (
   oldBuffer,
   newBuffer,
 ) {
+  //>>includeStart('debug', pragmas.debug);
+  Check.typeOf.object("oldBuffer", oldBuffer);
+  Check.typeOf.object("newBuffer", newBuffer);
+  //>>includeEnd('debug');
+
   if (!this.hasGeodeticSurfaceNormals) {
     return;
   }
@@ -326,7 +376,20 @@ TerrainEncoding.prototype.removeGeodeticSurfaceNormals = function (
   }
 };
 
+/**
+ * Decode a position from the vertex buffer.
+ *
+ * @param {Float32Array} buffer The buffer to decode from.
+ * @param {number} index The index of the vertex to decode.
+ * @param {Cartesian3} [result] The object to store the result in.
+ * @returns {Cartesian3} The decoded position.
+ */
 TerrainEncoding.prototype.decodePosition = function (buffer, index, result) {
+  //>>includeStart('debug', pragmas.debug);
+  Check.typeOf.object("buffer", buffer);
+  Check.typeOf.number("index", index);
+  //>>includeEnd('debug');
+
   if (!defined(result)) {
     result = new Cartesian3();
   }
@@ -356,6 +419,14 @@ TerrainEncoding.prototype.decodePosition = function (buffer, index, result) {
   return Cartesian3.add(result, this.center, result);
 };
 
+/**
+ * Decode a position from the vertex buffer and apply vertical exaggeration.
+ *
+ * @param {Float32Array} buffer
+ * @param {number} index
+ * @param {Cartesian3} [result]
+ * @returns {Cartesian3} The exaggerated position.
+ */
 TerrainEncoding.prototype.getExaggeratedPosition = function (
   buffer,
   index,
@@ -389,11 +460,24 @@ TerrainEncoding.prototype.getExaggeratedPosition = function (
   return result;
 };
 
+/**
+ * Decode texture coordinates from the vertex buffer.
+ *
+ * @param {Float32Array} buffer The buffer to decode from.
+ * @param {number} index The index of the vertex to decode.
+ * @param {Cartesian2} [result] The object to store the result in.
+ * @returns {Cartesian2} The decoded texture coordinates.
+ */
 TerrainEncoding.prototype.decodeTextureCoordinates = function (
   buffer,
   index,
   result,
 ) {
+  //>>includeStart('debug', pragmas.debug);
+  Check.typeOf.object("buffer", buffer);
+  Check.typeOf.number("index", index);
+  //>>includeEnd('debug');
+
   if (!defined(result)) {
     result = new Cartesian2();
   }
@@ -410,7 +494,19 @@ TerrainEncoding.prototype.decodeTextureCoordinates = function (
   return Cartesian2.fromElements(buffer[index + 4], buffer[index + 5], result);
 };
 
+/**
+ * Decode a height from the vertex buffer.
+ *
+ * @param {Float32Array} buffer The buffer to decode from.
+ * @param {number} index The index of the vertex to decode.
+ * @returns {number} The decoded height.
+ */
 TerrainEncoding.prototype.decodeHeight = function (buffer, index) {
+  //>>includeStart('debug', pragmas.debug);
+  Check.typeOf.object("buffer", buffer);
+  Check.typeOf.number("index", index);
+  //>>includeEnd('debug');
+
   index *= this.stride;
 
   if (this.quantization === TerrainQuantization.BITS12) {
@@ -426,7 +522,19 @@ TerrainEncoding.prototype.decodeHeight = function (buffer, index) {
   return buffer[index + 3];
 };
 
+/**
+ * Decode a web mercator T coordinate from the vertex buffer.
+ *
+ * @param {Float32Array} buffer The buffer to decode from.
+ * @param {number} index The index of the vertex to decode.
+ * @returns {number} The decoded web mercator T coordinate.
+ */
 TerrainEncoding.prototype.decodeWebMercatorT = function (buffer, index) {
+  //>>includeStart('debug', pragmas.debug);
+  Check.typeOf.object("buffer", buffer);
+  Check.typeOf.number("index", index);
+  //>>includeEnd('debug');
+
   index *= this.stride;
 
   if (this.quantization === TerrainQuantization.BITS12) {
@@ -439,11 +547,24 @@ TerrainEncoding.prototype.decodeWebMercatorT = function (buffer, index) {
   return buffer[index + 6];
 };
 
+/**
+ * Decode an oct-encoded normal from the vertex buffer.
+ *
+ * @param {Float32Array} buffer The buffer to decode from.
+ * @param {number} index The index of the vertex to decode.
+ * @param {Cartesian2} [result] The object to store the result in.
+ * @returns {Cartesian2} The decoded oct-encoded normal.
+ */
 TerrainEncoding.prototype.getOctEncodedNormal = function (
   buffer,
   index,
   result,
 ) {
+  //>>includeStart('debug', pragmas.debug);
+  Check.typeOf.object("buffer", buffer);
+  Check.typeOf.number("index", index);
+  //>>includeEnd('debug');
+
   index = index * this.stride + this._offsetVertexNormal;
 
   const temp = buffer[index] / 256.0;
@@ -453,11 +574,42 @@ TerrainEncoding.prototype.getOctEncodedNormal = function (
   return Cartesian2.fromElements(x, y, result);
 };
 
+/**
+ * @param {Float32Array} buffer
+ * @param {number} index
+ * @param {Cartesian3} result
+ * @returns {Cartesian3}
+ */
+TerrainEncoding.prototype.decodeNormal = function (buffer, index, result) {
+  //>>includeStart('debug', pragmas.debug);
+  Check.typeOf.object("buffer", buffer);
+  Check.typeOf.number("index", index);
+  Check.typeOf.object("result", result);
+  //>>includeEnd('debug');
+
+  const bufferIndex = (index = index * this.stride + this._offsetVertexNormal);
+  return AttributeCompression.octDecodeFloat(buffer[bufferIndex], result);
+};
+
+/**
+ * Decode a geodetic surface normal from the vertex buffer.
+ *
+ * @param {Float32Array} buffer The buffer to decode from.
+ * @param {number} index The index of the vertex to decode.
+ * @param {Cartesian3} result The object to store the result in.
+ * @returns {Cartesian3} The decoded geodetic surface normal.
+ */
 TerrainEncoding.prototype.decodeGeodeticSurfaceNormal = function (
   buffer,
   index,
   result,
 ) {
+  //>>includeStart('debug', pragmas.debug);
+  Check.typeOf.object("buffer", buffer);
+  Check.typeOf.number("index", index);
+  Check.typeOf.object("result", result);
+  //>>includeEnd('debug');
+
   index = index * this.stride + this._offsetGeodeticSurfaceNormal;
 
   result.x = buffer[index];
@@ -466,6 +618,9 @@ TerrainEncoding.prototype.decodeGeodeticSurfaceNormal = function (
   return result;
 };
 
+/**
+ * Calculate the stride and offsets for sampling the vertex buffer.
+ */
 TerrainEncoding.prototype._calculateStrideAndOffsets = function () {
   let vertexStride = 0;
 
@@ -502,7 +657,17 @@ const attributesIndicesBits12 = {
   geodeticSurfaceNormal: 2,
 };
 
+/**
+ * Get descriptors of the attributes stored in the vertex buffer.
+ *
+ * @param {Float32Array} buffer The vertex buffer.
+ * @returns {object[]} The attributes.
+ */
 TerrainEncoding.prototype.getAttributes = function (buffer) {
+  //>>includeStart('debug', pragmas.debug);
+  Check.typeOf.object("buffer", buffer);
+  //>>includeEnd('debug');
+
   const datatype = ComponentDatatype.FLOAT;
   const sizeInBytes = ComponentDatatype.getSizeInBytes(datatype);
   const strideInBytes = this.stride * sizeInBytes;
@@ -560,6 +725,11 @@ TerrainEncoding.prototype.getAttributes = function (buffer) {
   return attributes;
 };
 
+/**
+ * Get indices pointing to the attribute locations in the vertex buffer.
+ *
+ * @returns {object} The attribute indices.
+ */
 TerrainEncoding.prototype.getAttributeLocations = function () {
   if (this.quantization === TerrainQuantization.NONE) {
     return attributesIndicesNone;
@@ -567,6 +737,13 @@ TerrainEncoding.prototype.getAttributeLocations = function () {
   return attributesIndicesBits12;
 };
 
+/**
+ * Clones a TerrainEncoding object.
+ *
+ * @param {TerrainEncoding} [encoding] The encoding to clone.
+ * @param {TerrainEncoding} [result] The object to store the cloned encoding.
+ * @returns {TerrainEncoding|undefined} The cloned encoding.
+ */
 TerrainEncoding.clone = function (encoding, result) {
   if (!defined(encoding)) {
     return undefined;

package/Source/Core/TerrainMesh.js

@@ -22,10 +22,10 @@
  * @param {number} [vertexStride=6] The number of components in each vertex.
  * @param {OrientedBoundingBox} [orientedBoundingBox] A bounding box that completely contains the tile.
  * @param {TerrainEncoding} encoding Information used to decode the mesh.
- * @param {number[]} westIndicesSouthToNorth The indices of the vertices on the Western edge of the tile, ordered from South to North (clockwise).
- * @param {number[]} southIndicesEastToWest The indices of the vertices on the Southern edge of the tile, ordered from East to West (clockwise).
- * @param {number[]} eastIndicesNorthToSouth The indices of the vertices on the Eastern edge of the tile, ordered from North to South (clockwise).
- * @param {number[]} northIndicesWestToEast The indices of the vertices on the Northern edge of the tile, ordered from West to East (clockwise).
+ * @param {number[]|Uint8Array|Uint16Array|Uint32Array} westIndicesSouthToNorth The indices of the vertices on the Western edge of the tile, ordered from South to North (clockwise).
+ * @param {number[]|Uint8Array|Uint16Array|Uint32Array} southIndicesEastToWest The indices of the vertices on the Southern edge of the tile, ordered from East to West (clockwise).
+ * @param {number[]|Uint8Array|Uint16Array|Uint32Array} eastIndicesNorthToSouth The indices of the vertices on the Eastern edge of the tile, ordered from North to South (clockwise).
+ * @param {number[]|Uint8Array|Uint16Array|Uint32Array} northIndicesWestToEast The indices of the vertices on the Northern edge of the tile, ordered from West to East (clockwise).
  *
  * @private
  */
@@ -129,25 +129,25 @@ function TerrainMesh(
 
   /**
    * The indices of the vertices on the Western edge of the tile, ordered from South to North (clockwise).
-   * @type {number[]}
+   * @type {number[]|Uint8Array|Uint16Array|Uint32Array}
    */
   this.westIndicesSouthToNorth = westIndicesSouthToNorth;
 
   /**
    * The indices of the vertices on the Southern edge of the tile, ordered from East to West (clockwise).
-   * @type {number[]}
+   * @type {number[]|Uint8Array|Uint16Array|Uint32Array}
    */
   this.southIndicesEastToWest = southIndicesEastToWest;
 
   /**
    * The indices of the vertices on the Eastern edge of the tile, ordered from North to South (clockwise).
-   * @type {number[]}
+   * @type {number[]|Uint8Array|Uint16Array|Uint32Array}
    */
   this.eastIndicesNorthToSouth = eastIndicesNorthToSouth;
 
   /**
    * The indices of the vertices on the Northern edge of the tile, ordered from West to East (clockwise).
-   * @type {number[]}
+   * @type {number[]|Uint8Array|Uint16Array|Uint32Array}
    */
   this.northIndicesWestToEast = northIndicesWestToEast;
 }