@cesium/engine 21.0.1 → 22.1.0

package/Source/Core/Resource.js

@@ -917,7 +917,7 @@ Resource.prototype.fetchImage = function (options) {
     this.isBlobUri ||
     (!this.hasHeaders && !preferBlob)
   ) {
-    return fetchImage({
+    return this._fetchImage({
       resource: this,
       flipY: flipY,
       skipColorSpaceConversion: skipColorSpaceConversion,
@@ -957,8 +957,7 @@ Resource.prototype.fetchImage = function (options) {
         url: blobUrl,
       });
 
-      return fetchImage({
-        resource: generatedBlobResource,
+      return generatedBlobResource._fetchImage({
         flipY: flipY,
         skipColorSpaceConversion: skipColorSpaceConversion,
         preferImageBitmap: false,
@@ -997,16 +996,15 @@ Resource.prototype.fetchImage = function (options) {
 
 /**
  * Fetches an image and returns a promise to it.
- *
  * @param {object} [options] An object with the following properties.
- * @param {Resource} [options.resource] Resource object that points to an image to fetch.
  * @param {boolean} [options.preferImageBitmap] If true, image will be decoded during fetch and an <code>ImageBitmap</code> is returned.
  * @param {boolean} [options.flipY] If true, image will be vertically flipped during decode. Only applies if the browser supports <code>createImageBitmap</code>.
  * @param {boolean} [options.skipColorSpaceConversion=false] If true, any custom gamma or color profiles in the image will be ignored. Only applies if the browser supports <code>createImageBitmap</code>.
+ * @returns {Promise<ImageBitmap|HTMLImageElement>|undefined} a promise that will resolve to the requested data when loaded. Returns undefined if the request has been throttled and cannot be made at this time.
  * @private
  */
-function fetchImage(options) {
-  const resource = options.resource;
+Resource.prototype._fetchImage = function (options) {
+  const resource = this;
   const flipY = options.flipY;
   const skipColorSpaceConversion = options.skipColorSpaceConversion;
   const preferImageBitmap = options.preferImageBitmap;
@@ -1050,8 +1048,7 @@ function fetchImage(options) {
         request.state = RequestState.UNISSUED;
         request.deferred = undefined;
 
-        return fetchImage({
-          resource: resource,
+        return resource._fetchImage({
           flipY: flipY,
           skipColorSpaceConversion: skipColorSpaceConversion,
           preferImageBitmap: preferImageBitmap,
@@ -1060,7 +1057,7 @@ function fetchImage(options) {
       return Promise.reject(e);
     });
   });
-}
+};
 
 /**
  * Creates a Resource and calls fetchImage() on it.
@@ -1962,6 +1959,7 @@ Resource._Implementations.createImage = function (
   flipY,
   skipColorSpaceConversion,
   preferImageBitmap,
+  headers,
 ) {
   const url = request.url;
   // Passing an Image to createImageBitmap will force it to run on the main thread
@@ -1985,7 +1983,7 @@ Resource._Implementations.createImage = function (
         responseType,
         method,
         undefined,
-        undefined,
+        headers,
         xhrDeferred,
         undefined,
         undefined,
@@ -2027,6 +2025,12 @@ Resource._Implementations.createImage = function (
  * Wrapper for createImageBitmap
  *
  * @private
+ * @param {Blob} blob The image blob.
+ * @param {object} options An object containing the following properties:
+ * @param {boolean} options.flipY Whether to flip the image Y axis.
+ * @param {boolean} options.premultiplyAlpha Whether to premultiply the alpha channel.
+ * @param {boolean} options.skipColorSpaceConversion Whether to skip color space conversion.
+ * @returns {Promise<ImageBitmap>} A promise that resolves to the created image bitmap.
  */
 Resource.createImageBitmapFromBlob = function (blob, options) {
   Check.defined("options", options);

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;