@cesium/engine 12.0.1 → 13.1.0

package/Source/Scene/ITwinData.js

@@ -0,0 +1,208 @@
+import Cesium3DTileset from "./Cesium3DTileset.js";
+import defined from "../Core/defined.js";
+import Resource from "../Core/Resource.js";
+import ITwinPlatform from "../Core/ITwinPlatform.js";
+import RuntimeError from "../Core/RuntimeError.js";
+import Check from "../Core/Check.js";
+import KmlDataSource from "../DataSources/KmlDataSource.js";
+import GeoJsonDataSource from "../DataSources/GeoJsonDataSource.js";
+
+/**
+ * Methods for loading iTwin platform data into CesiumJS
+ *
+ * @experimental This feature is not final and is subject to change without Cesium's standard deprecation policy.
+ *
+ * @see ITwinPlatform
+ * @namespace ITwinData
+ */
+const ITwinData = {};
+
+/**
+ * Create a {@link Cesium3DTileset} for the given iModel id using iTwin's Mesh Export API.
+ *
+ * If there is not a completed export available for the given iModel id, the returned promise will resolve to <code>undefined</code>.
+ * We recommend waiting 10-20 seconds and trying to load the tileset again.
+ * If all exports are Invalid this will throw an error.
+ *
+ * @example
+ * const tileset = await Cesium.ITwinData.createTilesetFromIModelId(iModelId);
+ * if (Cesium.defined(tileset)) {
+ *   viewer.scene.primitives.add(tileset);
+ * }
+ *
+ * @experimental This feature is not final and is subject to change without Cesium's standard deprecation policy.
+ *
+ * @param {string} iModelId The id of the iModel to load
+ * @param {Cesium3DTileset.ConstructorOptions} [options] Object containing options to pass to the internally created {@link Cesium3DTileset}.
+ * @returns {Promise<Cesium3DTileset | undefined>} A promise that will resolve to the created 3D tileset or <code>undefined</code> if there is no completed export for the given iModel id
+ *
+ * @throws {RuntimeError} If all exports for the given iModel are Invalid
+ * @throws {RuntimeError} If the iTwin API request is not successful
+ */
+ITwinData.createTilesetFromIModelId = async function (iModelId, options) {
+  const { exports } = await ITwinPlatform.getExports(iModelId);
+
+  if (
+    exports.length > 0 &&
+    exports.every((exportObj) => {
+      return exportObj.status === ITwinPlatform.ExportStatus.Invalid;
+    })
+  ) {
+    throw new RuntimeError(
+      `All exports for this iModel are Invalid: ${iModelId}`,
+    );
+  }
+
+  const completeExport = exports.find((exportObj) => {
+    return exportObj.status === ITwinPlatform.ExportStatus.Complete;
+  });
+
+  if (!defined(completeExport)) {
+    return;
+  }
+
+  // Convert the link to the tileset url while preserving the search paramaters
+  // This link is only valid 1 hour
+  const baseUrl = new URL(completeExport._links.mesh.href);
+  baseUrl.pathname = `${baseUrl.pathname}/tileset.json`;
+  const tilesetUrl = baseUrl.toString();
+
+  const resource = new Resource({
+    url: tilesetUrl,
+  });
+
+  return Cesium3DTileset.fromUrl(resource, options);
+};
+
+/**
+ * Create a tileset for the specified reality data id. This function only works
+ * with 3D Tiles meshes and point clouds.
+ *
+ * If the <code>type</code> or <code>rootDocument</code> are not provided this function
+ * will first request the full metadata for the specified reality data to fill these values.
+ *
+ * @experimental This feature is not final and is subject to change without Cesium's standard deprecation policy.
+ *
+ * @param {string} iTwinId The id of the iTwin to load data from
+ * @param {string} realityDataId The id of the reality data to load
+ * @param {ITwinPlatform.RealityDataType} [type] The type of this reality data
+ * @param {string} [rootDocument] The path of the root document for this reality data
+ * @returns {Promise<Cesium3DTileset>}
+ *
+ * @throws {RuntimeError} if the type of reality data is not supported by this function
+ */
+ITwinData.createTilesetForRealityDataId = async function (
+  iTwinId,
+  realityDataId,
+  type,
+  rootDocument,
+) {
+  //>>includeStart('debug', pragmas.debug);
+  Check.typeOf.string("iTwinId", iTwinId);
+  Check.typeOf.string("realityDataId", realityDataId);
+  if (defined(type)) {
+    Check.typeOf.string("type", type);
+  }
+  if (defined(rootDocument)) {
+    Check.typeOf.string("rootDocument", rootDocument);
+  }
+  //>>includeEnd('debug')
+
+  if (!defined(type) || !defined(rootDocument)) {
+    const metadata = await ITwinPlatform.getRealityDataMetadata(
+      iTwinId,
+      realityDataId,
+    );
+    rootDocument = metadata.rootDocument;
+    type = metadata.type;
+  }
+
+  const supportedRealityDataTypes = [
+    ITwinPlatform.RealityDataType.Cesium3DTiles,
+    ITwinPlatform.RealityDataType.PNTS,
+    ITwinPlatform.RealityDataType.RealityMesh3DTiles,
+    ITwinPlatform.RealityDataType.Terrain3DTiles,
+  ];
+
+  if (!supportedRealityDataTypes.includes(type)) {
+    throw new RuntimeError(`Reality data type is not a mesh type: ${type}`);
+  }
+
+  const tilesetAccessUrl = await ITwinPlatform.getRealityDataURL(
+    iTwinId,
+    realityDataId,
+    rootDocument,
+  );
+
+  return Cesium3DTileset.fromUrl(tilesetAccessUrl, {
+    maximumScreenSpaceError: 4,
+  });
+};
+
+/**
+ * Create a data source of the correct type for the specified reality data id.
+ * This function only works for KML and GeoJSON type data.
+ *
+ * If the <code>type</code> or <code>rootDocument</code> are not provided this function
+ * will first request the full metadata for the specified reality data to fill these values.
+ *
+ * @param {string} iTwinId The id of the iTwin to load data from
+ * @param {string} realityDataId The id of the reality data to load
+ * @param {ITwinPlatform.RealityDataType} [type] The type of this reality data
+ * @param {string} [rootDocument] The path of the root document for this reality data
+ * @returns {Promise<GeoJsonDataSource | KmlDataSource>}
+ *
+ * @throws {RuntimeError} if the type of reality data is not supported by this function
+ */
+ITwinData.createDataSourceForRealityDataId = async function loadRealityData(
+  iTwinId,
+  realityDataId,
+  type,
+  rootDocument,
+) {
+  //>>includeStart('debug', pragmas.debug);
+  Check.typeOf.string("iTwinId", iTwinId);
+  Check.typeOf.string("realityDataId", realityDataId);
+  if (defined(type)) {
+    Check.typeOf.string("type", type);
+  }
+  if (defined(rootDocument)) {
+    Check.typeOf.string("rootDocument", rootDocument);
+  }
+  //>>includeEnd('debug')
+
+  if (!defined(type) || !defined(rootDocument)) {
+    const metadata = await ITwinPlatform.getRealityDataMetadata(
+      iTwinId,
+      realityDataId,
+    );
+    rootDocument = metadata.rootDocument;
+    type = metadata.type;
+  }
+
+  const supportedRealityDataTypes = [
+    ITwinPlatform.RealityDataType.KML,
+    ITwinPlatform.RealityDataType.GeoJSON,
+  ];
+
+  if (!supportedRealityDataTypes.includes(type)) {
+    throw new RuntimeError(
+      `Reality data type is not a data source type: ${type}`,
+    );
+  }
+
+  const tilesetAccessUrl = await ITwinPlatform.getRealityDataURL(
+    iTwinId,
+    realityDataId,
+    rootDocument,
+  );
+
+  if (type === ITwinPlatform.RealityDataType.GeoJSON) {
+    return GeoJsonDataSource.load(tilesetAccessUrl);
+  }
+
+  // If we get here it's guaranteed to be a KML type
+  return KmlDataSource.load(tilesetAccessUrl);
+};
+
+export default ITwinData;

package/Source/Scene/Label.js

@@ -400,8 +400,7 @@ Object.defineProperties(Label.prototype, {
       if (this._text !== value) {
         this._text = value;
 
-        // Strip soft-hyphen (auto-wrap) characters from input string
-        const renderedValue = value.replace(/\u00ad/g, "");
+        const renderedValue = Label.filterUnsupportedCharacters(value);
         this._renderedText = Label.enableRightToLeftDetection
           ? reverseRtl(renderedValue)
           : renderedValue;
@@ -1346,6 +1345,21 @@ Label.getScreenSpaceBoundingBox = function (
   return result;
 };
 
+/**
+ * Removes control characters and soft hyphon (auto-wrap) characters, which will cause an error when rendering a glyph. This does not remove tabs, carriage returns, or newlines.
+ * @private
+ * @param {string} text The original label text
+ * @returns {string} The renderable filtered text
+ */
+Label.filterUnsupportedCharacters = function (text) {
+  const problematicCharactersRegex = new RegExp(
+    // eslint-disable-next-line no-control-regex
+    /[\u0000-\u0008\u000E-\u001F\u00ad\u202a-\u206f\u200b-\u200f]/,
+    "g",
+  );
+  return text.replace(problematicCharactersRegex, "");
+};
+
 /**
  * Determines if this label equals another label.  Labels are equal if all their properties
  * are equal.  Labels in different collections can be equal.
@@ -1502,7 +1516,7 @@ function reverseBrackets(bracket) {
   }
 }
 
-//To add another language, simply add its Unicode block range(s) to the below regex.
+// To add another language, add its Unicode block range(s) to the below regex.
 const hebrew = "\u05D0-\u05EA";
 const arabic = "\u0600-\u06FF\u0750-\u077F\u08A0-\u08FF";
 const rtlChars = new RegExp(`[${hebrew}${arabic}]`);

package/Source/Scene/MetadataClassProperty.js

@@ -438,6 +438,10 @@ Object.defineProperties(MetadataClassProperty.prototype, {
   /**
    * The offset to be added to property values as part of the value transform.
    *
+   * This is always defined, even when `hasValueTransform` is `false`. If
+   * the class property JSON itself did not define it, then it will be
+   * initialized to the default value.
+   *
    * @memberof MetadataClassProperty.prototype
    * @type {number|number[]|number[][]}
    * @readonly
@@ -451,6 +455,10 @@ Object.defineProperties(MetadataClassProperty.prototype, {
   /**
    * The scale to be multiplied to property values as part of the value transform.
    *
+   * This is always defined, even when `hasValueTransform` is `false`. If
+   * the class property JSON itself did not define it, then it will be
+   * initialized to the default value.
+   *
    * @memberof MetadataClassProperty.prototype
    * @type {number|number[]|number[][]}
    * @readonly
@@ -1139,6 +1147,24 @@ function normalizeInPlace(values, valueType, normalizeFunction) {
 }
 
 /**
+ * Applies the value transform that is defined with the given offsets
+ * and scales to the given values.
+ *
+ * If the given values are not an array, then the given transformation
+ * function will be applied directly.
+ *
+ * If the values are an array, then this function will be called recursively
+ * with the array elements, boiling down to a component-wise application
+ * of the transformation function to the innermost array elements.
+ *
+ * @param {number|number[]|number[][]} values The input values
+ * @param {number|number[]|number[][]} offsets The offsets
+ * @param {number|number[]|number[][]} scales The scales
+ * @param {Function} transformationFunction The function with the signature
+ * `(value:number, offset:number, scale:number) : number` that will be
+ * applied to the innermost elements
+ * @returns The input values (or the result of applying the transformation
+ * function to a single value if the values have not been an array).
  * @private
  */
 MetadataClassProperty.valueTransformInPlace = function (

package/Source/Scene/MetadataPicking.js

@@ -6,6 +6,7 @@ import Matrix2 from "../Core/Matrix2.js";
 import Matrix3 from "../Core/Matrix3.js";
 import Matrix4 from "../Core/Matrix4.js";
 import RuntimeError from "../Core/RuntimeError.js";
+import MetadataClassProperty from "./MetadataClassProperty.js";
 import MetadataComponentType from "./MetadataComponentType.js";
 import MetadataType from "./MetadataType.js";
 
@@ -29,6 +30,10 @@ const MetadataPicking = {};
  * @param {DataView} dataView The data view
  * @param {number} index The index (byte offset)
  * @returns {number|bigint|undefined} The value
+ * @throws RuntimeError If the given component type is not a valid
+ * `MetadataComponentType`
+ * @throws RangeError If reading the data from the given data view would
+ * cause an out-of-bounds access
  *
  * @private
  */
@@ -43,21 +48,21 @@ MetadataPicking.decodeRawMetadataValue = function (
     case MetadataComponentType.UINT8:
       return dataView.getUint8(index);
     case MetadataComponentType.INT16:
-      return dataView.getInt16(index);
+      return dataView.getInt16(index, true);
     case MetadataComponentType.UINT16:
-      return dataView.getUint16(index);
+      return dataView.getUint16(index, true);
     case MetadataComponentType.INT32:
-      return dataView.getInt32(index);
+      return dataView.getInt32(index, true);
     case MetadataComponentType.UINT32:
-      return dataView.getUint32(index);
+      return dataView.getUint32(index, true);
     case MetadataComponentType.INT64:
-      return dataView.getBigInt64(index);
+      return dataView.getBigInt64(index, true);
     case MetadataComponentType.UINT64:
-      return dataView.getBigUint64(index);
+      return dataView.getBigUint64(index, true);
     case MetadataComponentType.FLOAT32:
-      return dataView.getFloat32(index);
+      return dataView.getFloat32(index, true);
     case MetadataComponentType.FLOAT64:
-      return dataView.getFloat64(index);
+      return dataView.getFloat64(index, true);
   }
   throw new RuntimeError(`Invalid component type: ${componentType}`);
 };
@@ -77,6 +82,10 @@ MetadataPicking.decodeRawMetadataValue = function (
  * @param {number} dataViewOffset The byte offset within the data view from
  * which the component should be read
  * @returns {number|bigint|undefined} The metadata value component
+ * @throws RuntimeError If the component of the given property is not
+ * a valid `MetadataComponentType`
+ * @throws RangeError If reading the data from the given data view would
+ * cause an out-of-bounds access
  */
 MetadataPicking.decodeRawMetadataValueComponent = function (
   classProperty,
@@ -114,6 +123,11 @@ MetadataPicking.decodeRawMetadataValueComponent = function (
  * @param {number} elementIndex The index of the element. This is the index
  * inside the array for array-typed properties, and 0 for non-array types.
  * @returns {number|number[]|bigint|bigint[]|undefined} The decoded metadata value element
+ * @throws RuntimeError If the component of the given property is not
+ * a valid `MetadataComponentType`
+ * @throws RangeError If reading the data from the given data view would
+ * cause an out-of-bounds access
+ *
  */
 MetadataPicking.decodeRawMetadataValueElement = function (
   classProperty,
@@ -183,6 +197,7 @@ MetadataPicking.decodeRawMetadataValueElement = function (
  * @param {MetadataClassProperty} classProperty The `MetadataClassProperty`
  * @param {Uint8Array} rawPixelValues The raw values
  * @returns {number|bigint|number[]|bigint[]|undefined} The value
+ * @throws RuntimeError If the class property has an invalid component type
  *
  * @private
  */
@@ -229,7 +244,8 @@ MetadataPicking.decodeRawMetadataValues = function (
  *
  * @param {string} type The `ClassProperty` type
  * @param {number|bigint|number[]|bigint[]|undefined} value The input value
- * @returns {any} The object representation
+ * @returns {undefined|number|bigint|string|boolean|Cartesian2|Cartesian3|Cartesian4|Matrix2|Matrix3|Matrix4} The object representation
+ * @throws RuntimeError If the type is not a valid `MetadataType`
  */
 MetadataPicking.convertToObjectType = function (type, value) {
   if (!defined(value)) {
@@ -250,7 +266,7 @@ MetadataPicking.convertToObjectType = function (type, value) {
     case MetadataType.VEC3:
       return Cartesian3.unpack(numbers, 0, new Cartesian3());
     case MetadataType.VEC4:
-      return Cartesian4.unpack(numbers, 0, new Cartesian3());
+      return Cartesian4.unpack(numbers, 0, new Cartesian4());
     case MetadataType.MAT2:
       return Matrix2.unpack(numbers, 0, new Matrix2());
     case MetadataType.MAT3:
@@ -259,29 +275,104 @@ MetadataPicking.convertToObjectType = function (type, value) {
       return Matrix4.unpack(numbers, 0, new Matrix4());
   }
   // Should never happen:
-  return value;
+  throw new RuntimeError(`Invalid metadata object type: ${type}`);
+};
+
+/**
+ * Converts the given type into a raw value or array representation.
+ *
+ * For `VECn/MATn` types, the given value is converted into an array.
+ * For other types, the value is returned directly
+ *
+ * @param {string} type The `ClassProperty` type
+ * @param {undefined|number|bigint|string|boolean|Cartesian2|Cartesian3|Cartesian4|Matrix2|Matrix3|Matrix4} value The input value
+ * @returns {undefined|number|bigint|string|boolean|number[]} The array representation
+ * @throws RuntimeError If the type is not a valid `MetadataType`
+ */
+MetadataPicking.convertFromObjectType = function (type, value) {
+  if (!defined(value)) {
+    return value;
+  }
+  if (
+    type === MetadataType.SCALAR ||
+    type === MetadataType.STRING ||
+    type === MetadataType.BOOLEAN ||
+    type === MetadataType.ENUM
+  ) {
+    return value;
+  }
+  switch (type) {
+    case MetadataType.VEC2:
+      return Cartesian2.pack(value, Array(2));
+    case MetadataType.VEC3:
+      return Cartesian3.pack(value, Array(3));
+    case MetadataType.VEC4:
+      return Cartesian4.pack(value, Array(4));
+    case MetadataType.MAT2:
+      return Matrix2.pack(value, Array(4));
+    case MetadataType.MAT3:
+      return Matrix3.pack(value, Array(9));
+    case MetadataType.MAT4:
+      return Matrix4.pack(value, Array(16));
+  }
+  // Should never happen:
+  throw new RuntimeError(`Invalid metadata object type: ${type}`);
 };
 
 /**
  * Decode the given raw values into a metadata property value.
  *
- * This just converts the result of `decodeRawMetadataValues`
- * from array-based types into object types like `CartesianN`.
+ * This applies the value transform (offset/scale) to the result
+ * of `decodeRawMetadataValues`, and converts this from array-based
+ * types into object types like `CartesianN`.
  *
  * @param {MetadataClassProperty} classProperty The `MetadataClassProperty`
+ * @param {object} metadataProperty The
+ * `PropertyTextureProperty` or `PropertyAttributeProperty`
  * @param {Uint8Array} rawPixelValues The raw values
- * @returns {any} The value
+ * @returns {MetadataValue} The value
+ * @throws RuntimeError If the class property has an invalid type
+ * or component type
+ * @throws RangeError If the given pixel values do not have sufficient
+ * size to contain the expected value type
  *
  * @private
  */
 MetadataPicking.decodeMetadataValues = function (
   classProperty,
+  metadataProperty,
   rawPixelValues,
 ) {
-  const arrayBasedResult = MetadataPicking.decodeRawMetadataValues(
+  let arrayBasedResult = MetadataPicking.decodeRawMetadataValues(
     classProperty,
     rawPixelValues,
   );
+
+  if (metadataProperty.hasValueTransform) {
+    // In the MetadataClassProperty, these offset/scale are always in
+    // their array-based form (e.g. a number[3] for `VEC3`). But for
+    // the PropertyTextureProperty and PropertyAttributeProperty,
+    // the type of the offset/scale is defined to be
+    // number|Cartesian2|Cartesian3|Cartesian4|Matrix2|Matrix3|Matrix4
+    // So these types are converted into their array-based form here, before
+    // applying them with `MetadataClassProperty.valueTransformInPlace`
+
+    const offset = MetadataPicking.convertFromObjectType(
+      classProperty.type,
+      metadataProperty.offset,
+    );
+    const scale = MetadataPicking.convertFromObjectType(
+      classProperty.type,
+      metadataProperty.scale,
+    );
+    arrayBasedResult = MetadataClassProperty.valueTransformInPlace(
+      arrayBasedResult,
+      offset,
+      scale,
+      MetadataComponentType.applyValueTransform,
+    );
+  }
+
   if (classProperty.isArray) {
     const arrayLength = classProperty.arrayLength;
     const result = Array(arrayLength);
@@ -295,11 +386,11 @@ MetadataPicking.decodeMetadataValues = function (
     }
     return result;
   }
-  const result = MetadataPicking.convertToObjectType(
+  const objectResult = MetadataPicking.convertToObjectType(
     classProperty.type,
     arrayBasedResult,
   );
-  return result;
+  return objectResult;
 };
 
 export default Object.freeze(MetadataPicking);

package/Source/Scene/MetadataType.js

@@ -7,6 +7,26 @@ import Matrix2 from "../Core/Matrix2.js";
 import Matrix3 from "../Core/Matrix3.js";
 import Matrix4 from "../Core/Matrix4.js";
 
+/**
+ * An instance of a metadata value.<br>
+ * <br>
+ * This can be one of the following types:
+ * <ul>
+ *   <li><code>number</code> for type <code>SCALAR</code> and numeric component types except for <code>INT64</code> or <code>UINT64</code></li>
+ *   <li><code>bigint</code> for type <code>SCALAR</code> and component type <code>INT64</code> or <code>UINT64</code></li>
+ *   <li><code>string</code> for type <code>STRING</code> or <code>ENUM</code></li>
+ *   <li><code>boolean</code> for type <code>BOOLEAN</code></li>
+ *   <li><code>Cartesian2</code> for type <code>VEC2</code></li>
+ *   <li><code>Cartesian3</code> for type <code>VEC3</code></li>
+ *   <li><code>Cartesian4</code> for type <code>VEC4</code></li>
+ *   <li><code>Matrix2</code> for type <code>MAT2</code></li>
+ *   <li><code>Matrix3</code> for type <code>MAT3</code></li>
+ *   <li><code>Matrix4</code> for type <code>MAT4</code></li>
+ *   <li>Arrays of these types when the metadata value is an array</li>
+ * </ul>
+ * @typedef {(number|bigint|string|boolean|Cartesian2|Cartesian3|Cartesian4|Matrix2|Matrix3|Matrix4|number[]|bigint[]|string[]|boolean[]|Cartesian2[]|Cartesian3[]|Cartesian4[]|Matrix2[]|Matrix3[]|Matrix4[])} MetadataValue
+ */
+
 /**
  * An enum of metadata types. These metadata types are containers containing
  * one or more components of type {@link MetadataComponentType}

package/Source/Scene/Model/Extensions/Gpm/GltfMeshPrimitiveGpmLoader.js

@@ -234,7 +234,7 @@ GltfMeshPrimitiveGpmLoader.ppeTexturesMetadataSchemaCache = new Map();
  * Create the JSON description of a metadata class that treats
  * the given PPE texture as a property texture property.
  *
- * @param {any} ppeTexture - The PPE texture
+ * @param {PpeTexture} ppeTexture - The PPE texture
  * @param {number} index - The index of the texture in the extension
  * @returns The class JSON
  */
@@ -268,9 +268,9 @@ GltfMeshPrimitiveGpmLoader._createPpeTextureClassJson = function (
   // property values when they are `normalized`, the values will be
   // declared as `normalized` here.
   // The normalization factor will later have to be cancelled out,
-  // when integrating the `scale` into the actual property texture
-  // property. In the property texture property, the `scale` has to
-  // be multiplied by 255.
+  // with the `scale` being multiplied by 255.
+  const offset = ppeTexture.offset ?? 0.0;
+  const scale = (ppeTexture.scale ?? 1.0) * 255.0;
   const classJson = {
     name: `PPE texture class ${index}`,
     properties: {
@@ -279,6 +279,8 @@ GltfMeshPrimitiveGpmLoader._createPpeTextureClassJson = function (
         type: "SCALAR",
         componentType: "UINT8",
         normalized: true,
+        offset: offset,
+        scale: scale,
         min: traits.min,
         max: traits.max,
       },
@@ -406,19 +408,12 @@ GltfMeshPrimitiveGpmLoader._convertToStructuralMetadata = function (
     const ppePropertyName = traits.source;
     const metadataClass = ppeTexturesMetadataSchema.classes[classId];
 
-    // The class property has been declared as `normalized`, so
-    // that `offset` and `scale` can be applied. The normalization
-    // factor has to be cancelled out here, by multiplying the
-    // `scale` with 255.
-    const scale = (ppeTexture.scale ?? 1.0) * 255.0;
     const ppeTextureAsPropertyTexture = {
       class: classId,
       properties: {
         [ppePropertyName]: {
           index: ppeTexture.index,
           texCoord: ppeTexture.texCoord,
-          offset: ppeTexture.offset,
-          scale: scale,
         },
       },
     };

package/Source/Scene/Model/Model.js

@@ -1823,7 +1823,7 @@ Model.prototype.applyArticulations = function () {
  *
  * The given name may be the name of a glTF extension, like `"EXT_example_extension"`.
  * If the specified extension was present in the root of the underlying glTF asset,
- * and a loder for the specified extension has processed the extension data, then
+ * and a loader for the specified extension has processed the extension data, then
  * this will return the model representation of the extension.
  *
  * @param {string} extensionName The name of the extension

package/Source/Scene/Model/Model3DTileContent.js

@@ -152,12 +152,34 @@ Object.defineProperties(Model3DTileContent.prototype, {
   },
 });
 
+/**
+ * Returns an array containing the `texture.id` values for all textures
+ * that are part of this content.
+ *
+ * @returns {string[]} The texture IDs
+ */
+Model3DTileContent.prototype.getTextureIds = function () {
+  return this._model.statistics.getTextureIds();
+};
+
+/**
+ * Returns the length, in bytes, of the texture data for the texture with
+ * the given ID that is part of this content, or `undefined` if this
+ * content does not contain the texture with the given ID.
+ *
+ * @param {string} textureId The texture ID
+ * @returns {number|undefined} The texture byte length
+ */
+Model3DTileContent.prototype.getTextureByteLengthById = function (textureId) {
+  return this._model.statistics.getTextureByteLengthById(textureId);
+};
+
 /**
  * Returns the object that was created for the given extension.
  *
  * The given name may be the name of a glTF extension, like `"EXT_example_extension"`.
  * If the specified extension was present in the root of the underlying glTF asset,
- * and a loder for the specified extension has processed the extension data, then
+ * and a loader for the specified extension has processed the extension data, then
  * this will return the model representation of the extension.
  *
  * @param {string} extensionName The name of the extension