@cesium/engine 26.0.0 → 26.2.0

package/Source/Scene/GltfBufferViewLoader.js

@@ -1,7 +1,7 @@
 import Check from "../Core/Check.js";
 import Frozen from "../Core/Frozen.js";
 import defined from "../Core/defined.js";
-import hasExtension from "./hasExtension.js";
+import findMeshoptExtension from "./findMeshoptExtension.js";
 import { MeshoptDecoder } from "meshoptimizer";
 import ResourceLoader from "./ResourceLoader.js";
 import ResourceLoaderState from "./ResourceLoaderState.js";
@@ -54,8 +54,8 @@ class GltfBufferViewLoader extends ResourceLoader {
     let meshoptMode;
     let meshoptFilter;
 
-    if (hasExtension(bufferView, "EXT_meshopt_compression")) {
-      const meshopt = bufferView.extensions.EXT_meshopt_compression;
+    const meshopt = findMeshoptExtension(bufferView);
+    if (defined(meshopt)) {
       bufferId = meshopt.buffer;
       byteOffset = meshopt.byteOffset ?? 0;
       byteLength = meshopt.byteLength;

package/Source/Scene/GltfLoader.js

@@ -61,6 +61,7 @@ const {
   Specular,
   Anisotropy,
   Clearcoat,
+  PlanarFill,
   LineStyle,
   Material,
   Vector,
@@ -534,6 +535,7 @@ class GltfLoader extends ResourceLoader {
 
 /**
  * Loads the gltf object
+ * @ignore
  */
 async function loadGltfJson(loader) {
   loader._state = GltfLoaderState.LOADING;
@@ -1786,6 +1788,23 @@ function loadClearcoat(loader, clearcoatInfo, frameState) {
   return clearcoat;
 }
 
+/**
+ * Load properties for the BENTLEY_materials_planar_fill extension.
+ *
+ * Note: The wireframeFill property is loaded but is currently a NO-OP in the
+ * rendering pipeline. CesiumJS does not yet have a proper wireframe rendering
+ * mode, so this value is stored for completeness but has no effect on rendering.
+ * See https://github.com/CesiumGS/cesium/issues/13620 and
+ * MaterialPipelineStage.js for more details.
+ *
+ * @param {object} planarFillInfo The contents of the BENTLEY_materials_planar_fill extension in the parsed glTF JSON
+ * @returns {ModelComponents.PlanarFill}
+ * @private
+ */
+function loadPlanarFill(planarFillInfo) {
+  return new PlanarFill(planarFillInfo);
+}
+
 function loadLineStyle(lineStyleInfo) {
   if (!defined(lineStyleInfo)) {
     return undefined;
@@ -1832,6 +1851,7 @@ function loadMaterial(loader, gltfMaterial, frameState) {
   const pbrAnisotropy = extensions.KHR_materials_anisotropy;
   const pbrClearcoat = extensions.KHR_materials_clearcoat;
   const pbrMetallicRoughness = gltfMaterial.pbrMetallicRoughness;
+  const planarFill = extensions.BENTLEY_materials_planar_fill;
 
   material.unlit = defined(extensions.KHR_materials_unlit);
 
@@ -1888,6 +1908,11 @@ function loadMaterial(loader, gltfMaterial, frameState) {
   material.alphaCutoff = gltfMaterial.alphaCutoff;
   material.doubleSided = gltfMaterial.doubleSided;
 
+  // BENTLEY_materials_planar_fill extension
+  if (defined(planarFill)) {
+    material.planarFill = loadPlanarFill(planarFill);
+  }
+
   // BENTLEY_materials_point_style extension
   const pointStyleExtension = extensions.BENTLEY_materials_point_style;
   if (defined(pointStyleExtension) && defined(pointStyleExtension.diameter)) {
@@ -2155,7 +2180,7 @@ function loadEdgeVisibilityLineStrings(
       throw new RuntimeError("Edge visibility line string accessor not found!");
     }
 
-    const indices = loadAccessor(loader, accessor);
+    const indices = loadAccessorTypedArray(loader, accessor);
     const restartIndex = getLineStringPrimitiveRestartValue(
       accessor.componentType,
     );
@@ -2187,7 +2212,10 @@ function loadEdgeVisibility(loader, edgeVisibilityExtension) {
     if (!defined(visibilityAccessor)) {
       throw new RuntimeError("Edge visibility accessor not found!");
     }
-    edgeVisibility.visibility = loadAccessor(loader, visibilityAccessor);
+    edgeVisibility.visibility = loadAccessorTypedArray(
+      loader,
+      visibilityAccessor,
+    );
   }
 
   edgeVisibility.materialColor = getEdgeVisibilityMaterialColor(
@@ -2199,7 +2227,9 @@ function loadEdgeVisibility(loader, edgeVisibilityExtension) {
     const silhouetteNormalsAccessor =
       loader.gltfJson.accessors[edgeVisibilityExtension.silhouetteNormals];
     if (defined(silhouetteNormalsAccessor)) {
-      edgeVisibility.silhouetteNormals = loadAccessor(
+      // Packed typed array (x0,y0,z0, x1,y1,z1, ...), not an array of
+      // Cartesian3s. Avoids a large JS heap cost for edge-heavy tiles.
+      edgeVisibility.silhouetteNormals = loadAccessorTypedArray(
         loader,
         silhouetteNormalsAccessor,
       );

package/Source/Scene/GltfLoaderUtil.js

@@ -111,6 +111,22 @@ GltfLoaderUtil.createSampler = function (options) {
     }
   }
 
+  if (!TextureWrap.validate(wrapS)) {
+    wrapS = TextureWrap.REPEAT;
+  }
+
+  if (!TextureWrap.validate(wrapT)) {
+    wrapT = TextureWrap.REPEAT;
+  }
+
+  if (!TextureMinificationFilter.validate(minFilter)) {
+    minFilter = TextureMinificationFilter.LINEAR;
+  }
+
+  if (!TextureMagnificationFilter.validate(magFilter)) {
+    magFilter = TextureMagnificationFilter.LINEAR;
+  }
+
   return new Sampler({
     wrapS: wrapS,
     wrapT: wrapT,
@@ -164,10 +180,10 @@ GltfLoaderUtil.createModelTextureReader = function (options) {
 
     // prettier-ignore
     transform = new Matrix3(
-        Math.cos(rotation) * scale.x, -Math.sin(rotation) * scale.y, offset.x,
-        Math.sin(rotation) * scale.x, Math.cos(rotation) * scale.y, offset.y,
-        0.0, 0.0, 1.0
-      );
+      Math.cos(rotation) * scale.x, -Math.sin(rotation) * scale.y, offset.x,
+      Math.sin(rotation) * scale.x, Math.cos(rotation) * scale.y, offset.y,
+      0.0, 0.0, 1.0
+    );
   }
 
   const modelTextureReader = new ModelComponents.TextureReader();

package/Source/Scene/GltfPipeline/forEachTextureInMaterial.js

@@ -73,6 +73,16 @@ function forEachTextureInMaterial(material, handler) {
       }
     }
 
+    // Transmission extension
+    const transmission = extensions.KHR_materials_transmission;
+    if (defined(transmission) && defined(transmission.transmissionTexture)) {
+      const textureInfo = transmission.transmissionTexture;
+      const value = handler(textureInfo.index, textureInfo);
+      if (defined(value)) {
+        return value;
+      }
+    }
+
     // Materials common extension (may be present in models converted from glTF 1.0)
     const materialsCommon = extensions.KHR_materials_common;
     if (defined(materialsCommon) && defined(materialsCommon.values)) {

package/Source/Scene/GltfPipeline/removeUnusedElements.js

@@ -148,11 +148,16 @@ Remove.buffer = function (gltf, bufferId) {
       bufferView.buffer--;
     }
 
-    if (
-      defined(bufferView.extensions) &&
-      defined(bufferView.extensions.EXT_meshopt_compression)
-    ) {
-      bufferView.extensions.EXT_meshopt_compression.buffer--;
+    const extensions = bufferView.extensions;
+    if (defined(extensions)) {
+      const ext = extensions.EXT_meshopt_compression;
+      if (defined(ext) && ext.buffer > bufferId) {
+        ext.buffer--;
+      }
+      const khr = extensions.KHR_meshopt_compression;
+      if (defined(khr) && khr.buffer > bufferId) {
+        khr.buffer--;
+      }
     }
   });
 };
@@ -583,12 +588,17 @@ getListOfElementsIdsInUse.buffer = function (gltf) {
     if (defined(bufferView.buffer)) {
       usedBufferIds[bufferView.buffer] = true;
     }
-    if (
-      defined(bufferView.extensions) &&
-      defined(bufferView.extensions.EXT_meshopt_compression)
-    ) {
-      usedBufferIds[bufferView.extensions.EXT_meshopt_compression.buffer] =
-        true;
+
+    const extensions = bufferView.extensions;
+    if (defined(extensions)) {
+      const ext = extensions.EXT_meshopt_compression;
+      if (defined(ext)) {
+        usedBufferIds[ext.buffer] = true;
+      }
+      const khr = extensions.KHR_meshopt_compression;
+      if (defined(khr)) {
+        usedBufferIds[khr.buffer] = true;
+      }
     }
   });
 

package/Source/Scene/GltfSpzLoader.js

@@ -267,7 +267,7 @@ async function loadResources(loader) {
   try {
     const bufferViewLoader = resourceCache.getBufferViewLoader({
       gltf: loader._gltf,
-      bufferViewId: 0,
+      bufferViewId: loader._spz.bufferView,
       gltfResource: loader._gltfResource,
       baseResource: loader._baseResource,
     });

package/Source/Scene/GltfVertexBufferLoader.js

@@ -29,6 +29,7 @@ class GltfVertexBufferLoader extends ResourceLoader {
    * @param {number} [options.bufferViewId] The bufferView ID corresponding to the vertex buffer.
    * @param {object} [options.primitive] The primitive containing the Draco extension.
    * @param {object} [options.draco] The Draco extension object.
+   * @param {object} [options.spz] The SPZ extension object.
    * @param {string} [options.attributeSemantic] The attribute semantic, e.g. POSITION or NORMAL.
    * @param {number} [options.accessorId] The accessor id.
    * @param {string} [options.cacheKey] The cache key of the resource.
@@ -36,7 +37,7 @@ class GltfVertexBufferLoader extends ResourceLoader {
    * @param {boolean} [options.loadBuffer=false] Load vertex buffer as a GPU vertex buffer.
    * @param {boolean} [options.loadTypedArray=false] Load vertex buffer as a typed array.
    *
-   * @exception {DeveloperError} One of options.bufferViewId and options.draco must be defined.
+   * @exception {DeveloperError} Exactly one vertex buffer source must be effective: options.bufferViewId, options.spz, or options.draco for options.attributeSemantic.
    * @exception {DeveloperError} When options.draco is defined options.attributeSemantic must also be defined.
    * @exception {DeveloperError} When options.draco is defined options.accessorId must also be defined.
    */
@@ -76,9 +77,11 @@ class GltfVertexBufferLoader extends ResourceLoader {
     const hasAttributeSemantic = defined(attributeSemantic);
     const hasAccessorId = defined(accessorId);
     const hasSpz = defined(spz);
-    if (hasBufferViewId === (hasDraco !== hasSpz)) {
+    const sourceCount =
+      Number(hasBufferViewId) + Number(hasDraco) + Number(hasSpz);
+    if (sourceCount !== 1) {
       throw new DeveloperError(
-        "One of options.bufferViewId, options.draco, or options.spz must be defined.",
+        "Exactly one vertex buffer source must be effective: options.bufferViewId, options.spz, or options.draco for options.attributeSemantic.",
       );
     }
 

package/Source/Scene/I3SDataProvider.js

@@ -408,7 +408,7 @@ I3SDataProvider.prototype.updateForPass = function (frameState, passState) {
 function buildLayerUrl(provider, layerId) {
   const dataProviderUrl = provider.resource.getUrlComponent();
 
-  let layerUrl = "";
+  let layerUrl;
   if (dataProviderUrl.match(/layers\/\d/)) {
     layerUrl = `${dataProviderUrl}`.replace(/\/+$/, "");
   } else {

package/Source/Scene/I3SLayer.js

@@ -31,7 +31,7 @@ function I3SLayer(dataProvider, layerData, parent) {
 
   const parentUrl = this._parent.resource.getUrlComponent();
 
-  let tilesetUrl = "";
+  let tilesetUrl;
   if (parentUrl.match(/layers\/\d/)) {
     tilesetUrl = `${parentUrl}`.replace(/\/+$/, "");
   } else {

package/Source/Scene/I3SNode.js

@@ -474,9 +474,9 @@ I3SNode.prototype._create3DTileDefinition = function () {
     }
   }
 
-  let boundingVolume = {};
+  let boundingVolume;
   let position;
-  let span = 0;
+  let span;
   if (defined(obb)) {
     boundingVolume = {
       box: [

package/Source/Scene/ImageryLayer.js

@@ -676,11 +676,11 @@ ImageryLayer.prototype.getImageryRectangle = function () {
  * Create skeletons for the imagery tiles that partially or completely overlap a given terrain
  * tile.
  *
- * @private
+ * @ignore
  *
  * @param {QuadtreeTile} tile The terrain tile.
  * @param {TerrainProvider|undefined} terrainProvider The terrain provider associated with the terrain tile.
- * @param {number} insertionPoint The position to insert new skeletons before in the tile's imagery list.
+ * @param {number} [insertionPoint] The position to insert new skeletons before in the tile's imagery list.
  * @returns {boolean} true if this layer overlaps any portion of the terrain tile; otherwise, false.
  */
 ImageryLayer.prototype._createTileImagerySkeletons = function (

package/Source/Scene/ImageryLayerCollection.js

@@ -1,10 +1,14 @@
 import defined from "../Core/defined.js";
+import Cartesian2 from "../Core/Cartesian2.js";
+import Cartographic from "../Core/Cartographic.js";
 import destroyObject from "../Core/destroyObject.js";
 import DeveloperError from "../Core/DeveloperError.js";
 import Event from "../Core/Event.js";
+import GeographicProjection from "../Core/GeographicProjection.js";
 import CesiumMath from "../Core/Math.js";
 import Rectangle from "../Core/Rectangle.js";
 import ImageryLayer from "./ImageryLayer.js";
+import ImageryState from "./ImageryState.js";
 
 /**
  * An ordered collection of imagery layers for rendering raster imagery on a {@link Globe} or {@link Cesium3DTileset}.
@@ -452,6 +456,152 @@ ImageryLayerCollection.prototype.pickImageryLayers = function (ray, scene) {
   return imageryLayers;
 };
 
+const nativeBoundingRectangleScratch = new Rectangle();
+const nativeApplicableRectangleScratch = new Rectangle();
+const southwestNativeScratch = new Cartesian2();
+const northeastNativeScratch = new Cartesian2();
+const southwestCartographicScratch = new Cartographic();
+const northeastCartographicScratch = new Cartographic();
+
+/**
+ * Maps a texture coordinate rectangle (UV space on the primitive) back to a
+ * geographic rectangle, using the primitive cartographic bounds and the
+ * imagery tiling scheme's native coordinates.
+ *
+ * @private
+ */
+
+function computeApplicableGeographicRectangle(
+  cartographicBoundingRectangle,
+  textureCoordinateRectangle,
+  imageryLayer,
+  result,
+) {
+  const tilingScheme = imageryLayer.imageryProvider.tilingScheme;
+  const nativeBoundingRectangle = tilingScheme.rectangleToNativeRectangle(
+    cartographicBoundingRectangle,
+    nativeBoundingRectangleScratch,
+  );
+
+  const epsilon = 1 / 1024; // 1/4 of a pixel in a typical 256x256 tile.
+  const applicableNative = nativeApplicableRectangleScratch;
+  applicableNative.west = CesiumMath.lerp(
+    nativeBoundingRectangle.west,
+    nativeBoundingRectangle.east,
+    textureCoordinateRectangle.minX - epsilon,
+  );
+  applicableNative.east = CesiumMath.lerp(
+    nativeBoundingRectangle.west,
+    nativeBoundingRectangle.east,
+    textureCoordinateRectangle.maxX + epsilon,
+  );
+  applicableNative.south = CesiumMath.lerp(
+    nativeBoundingRectangle.south,
+    nativeBoundingRectangle.north,
+    textureCoordinateRectangle.minY - epsilon,
+  );
+  applicableNative.north = CesiumMath.lerp(
+    nativeBoundingRectangle.south,
+    nativeBoundingRectangle.north,
+    textureCoordinateRectangle.maxY + epsilon,
+  );
+
+  if (!defined(result)) {
+    result = new Rectangle();
+  }
+
+  const projection = tilingScheme.projection;
+  if (projection instanceof GeographicProjection) {
+    result.west = CesiumMath.toRadians(applicableNative.west);
+    result.south = CesiumMath.toRadians(applicableNative.south);
+    result.east = CesiumMath.toRadians(applicableNative.east);
+    result.north = CesiumMath.toRadians(applicableNative.north);
+    return result;
+  }
+
+  southwestNativeScratch.x = applicableNative.west;
+  southwestNativeScratch.y = applicableNative.south;
+  northeastNativeScratch.x = applicableNative.east;
+  northeastNativeScratch.y = applicableNative.north;
+
+  const southwest = projection.unproject(
+    southwestNativeScratch,
+    southwestCartographicScratch,
+  );
+  const northeast = projection.unproject(
+    northeastNativeScratch,
+    northeastCartographicScratch,
+  );
+  result.west = southwest.longitude;
+  result.south = southwest.latitude;
+  result.east = northeast.longitude;
+  result.north = northeast.latitude;
+  return result;
+}
+
+function pickModelFeatures(model, pickedLocation, callback) {
+  const modelImagery = model._modelImagery;
+
+  if (!defined(modelImagery)) {
+    return;
+  }
+
+  const modelPrimitiveImageries = modelImagery._modelPrimitiveImageries;
+
+  if (!defined(modelPrimitiveImageries)) {
+    return;
+  }
+
+  for (let j = 0; j < modelPrimitiveImageries.length; j++) {
+    const modelPrimitiveImagery = modelPrimitiveImageries[j];
+    const coveragesPerLayer = modelPrimitiveImagery._coveragesPerLayer;
+    if (!defined(coveragesPerLayer)) {
+      continue;
+    }
+
+    for (let k = coveragesPerLayer.length - 1; k >= 0; --k) {
+      const coverages = coveragesPerLayer[k];
+
+      for (let l = 0; l < coverages.length; l++) {
+        const coverage = coverages[l];
+        const imagery = coverage.imagery;
+        const imageryLayer = imagery.imageryLayer;
+        const provider = imageryLayer.imageryProvider;
+
+        if (!defined(provider.pickFeatures)) {
+          continue;
+        }
+
+        if (!defined(imagery) || imagery.state !== ImageryState.READY) {
+          continue;
+        }
+
+        if (!Rectangle.contains(imagery.rectangle, pickedLocation)) {
+          continue;
+        }
+
+        const mappedPositions =
+          modelPrimitiveImagery.mappedPositionsForImageryLayer(imageryLayer);
+        const cartographicBoundingRectangle =
+          mappedPositions.cartographicBoundingRectangle;
+
+        const applicableRectangle = computeApplicableGeographicRectangle(
+          cartographicBoundingRectangle,
+          coverage.textureCoordinateRectangle,
+          imageryLayer,
+          applicableRectangleScratch,
+        );
+
+        if (!Rectangle.contains(applicableRectangle, pickedLocation)) {
+          continue;
+        }
+
+        callback(imagery);
+      }
+    }
+  }
+}
+
 /**
  * Asynchronously determines the imagery layer features that are intersected by a pick ray.  The intersected imagery
  * layer features are found by invoking {@link ImageryProvider#pickFeatures} for each imagery layer tile intersected
@@ -485,9 +635,30 @@ ImageryLayerCollection.prototype.pickImageryLayerFeatures = function (
   scene,
 ) {
   // Find the picked location on the globe.
-  const pickedPosition = scene.globe.pick(ray, scene);
+  let pickedPosition;
+
+  if (defined(scene.globe)) {
+    pickedPosition = scene.globe.pick(ray, scene);
+  }
+
+  let pickedModel;
+
   if (!defined(pickedPosition)) {
-    return;
+    const result = scene.pickFromRay(ray);
+
+    if (!defined(result)) {
+      return undefined;
+    }
+
+    pickedPosition = result.position;
+
+    if (!defined(pickedPosition)) {
+      return undefined;
+    }
+
+    if (defined(result.object) && defined(result.object.detail)) {
+      pickedModel = result.object.detail.model;
+    }
   }
 
   const pickedLocation =
@@ -496,7 +667,7 @@ ImageryLayerCollection.prototype.pickImageryLayerFeatures = function (
   const promises = [];
   const imageryLayers = [];
 
-  pickImageryHelper(scene, pickedLocation, true, function (imagery) {
+  function queuePickFeatures(imagery) {
     if (!imagery.imageryLayer.ready) {
       return undefined;
     }
@@ -512,11 +683,24 @@ ImageryLayerCollection.prototype.pickImageryLayerFeatures = function (
       promises.push(promise);
       imageryLayers.push(imagery.imageryLayer);
     }
-  });
+  }
+
+  if (defined(scene.globe)) {
+    pickImageryHelper(scene, pickedLocation, true, function (imagery) {
+      queuePickFeatures(imagery);
+    });
+  }
+
+  if (defined(pickedModel)) {
+    pickModelFeatures(pickedModel, pickedLocation, function (imagery) {
+      queuePickFeatures(imagery);
+    });
+  }
 
   if (promises.length === 0) {
     return undefined;
   }
+
   return Promise.all(promises).then(function (results) {
     const features = [];
     for (let resultIndex = 0; resultIndex < results.length; ++resultIndex) {
@@ -545,7 +729,7 @@ ImageryLayerCollection.prototype.pickImageryLayerFeatures = function (
 /**
  * Updates frame state to execute any queued texture re-projections.
  *
- * @private
+ * @ignore
  *
  * @param {FrameState} frameState The frameState.
  */
@@ -561,7 +745,7 @@ ImageryLayerCollection.prototype.queueReprojectionCommands = function (
 /**
  * Cancels re-projection commands queued for the next frame.
  *
- * @private
+ * @ignore
  */
 ImageryLayerCollection.prototype.cancelReprojections = function () {
   const layers = this._layers;

package/Source/Scene/IonImageryProvider.js

@@ -26,17 +26,13 @@ import IonImageryProviderFactory from "./IonImageryProviderFactory.js";
  * @alias IonImageryProvider
  * @constructor
  *
- * @param {IonImageryProvider.ConstructorOptions} [options] Object describing initialization options
- *
  * @example
  * const imageryLayer = Cesium.ImageryLayer.fromProviderAsync(Cesium.IonImageryProvider.fromAssetId(3812));
  * viewer.imageryLayers.add(imageryLayer);
  *
  * @see IonImageryProvider.fromAssetId
  */
-function IonImageryProvider(options) {
-  options = options ?? Frozen.EMPTY_OBJECT;
-
+function IonImageryProvider() {
   this._defaultAlpha = undefined;
   this._defaultNightAlpha = undefined;
   this._defaultDayAlpha = undefined;

package/Source/Scene/Label.js

@@ -1282,10 +1282,10 @@ Label.getScreenSpaceBoundingBox = function (
   screenSpacePosition,
   result,
 ) {
-  let x = 0;
-  let y = 0;
-  let width = 0;
-  let height = 0;
+  let x;
+  let y;
+  let width;
+  let height;
   const scale = label.totalScale;
 
   const backgroundBillboard = label._backgroundBillboard;

package/Source/Scene/LabelCollection.js

@@ -335,7 +335,7 @@ function updateBackgroundBillboard(
   // Label is shown and background is hidden - remove the background billboard
   if (label.show && !showBackground) {
     backgroundBillboardCollection.remove(backgroundBillboard);
-    label._backgroundBillboard = backgroundBillboard = undefined;
+    label._backgroundBillboard = undefined;
     return;
   }
 

package/Source/Scene/MVTDataProvider.js

@@ -23,6 +23,7 @@ import defined from "../Core/defined.js";
  * This object is normally not instantiated directly, use {@link MVTDataProvider.fromUrl}.
  * </div>
  *
+ * @extends UrlTemplate3DTilesDataProvider
  * @experimental This feature is not final and is subject to change without Cesium's standard deprecation policy.
  */
 class MVTDataProvider extends UrlTemplate3DTilesDataProvider {
@@ -35,6 +36,7 @@ class MVTDataProvider extends UrlTemplate3DTilesDataProvider {
    * @param {number} [options.maxZoom=14] Maximum zoom level represented in the generated tileset.
    * @param {Rectangle} [options.extent] Optional geographic extent in radians to constrain the generated tile tree.
    * @param {string} [options.featureIdProperty] MVT property name to use as feature ID.
+   * @returns {Promise<MVTDataProvider>}
    */
   static async fromUrl(url, options) {
     return /** @type {Promise<MVTDataProvider>} */ (

package/Source/Scene/Material.js

@@ -1099,6 +1099,7 @@ function createCubeMapUpdateFunction(uniformId) {
  * @param {Material} material The material to load the cubemap images for.
  * @param {string} uniformId The ID of the uniform that corresponds to the cubemap images.
  * @returns A promise that resolves when the images are loaded, or a resolved promise if image loading is not necessary.
+ * @ignore
  */
 function loadCubeMapImagesForUniform(material, uniformId) {
   const uniforms = material.uniforms;

package/Source/Scene/Model/B3dmLoader.js

@@ -163,7 +163,6 @@ class B3dmLoader extends ResourceLoader {
 
     const b3dm = B3dmParser.parse(this._arrayBuffer, this._byteOffset);
 
-    let batchLength = b3dm.batchLength;
     const featureTableJson = b3dm.featureTableJson;
     const featureTableBinary = b3dm.featureTableBinary;
     const batchTableJson = b3dm.batchTableJson;
@@ -173,7 +172,7 @@ class B3dmLoader extends ResourceLoader {
       featureTableJson,
       featureTableBinary,
     );
-    batchLength = featureTable.getGlobalProperty("BATCH_LENGTH");
+    const batchLength = featureTable.getGlobalProperty("BATCH_LENGTH");
     // Set batch length.
     this._batchLength = batchLength;
     // Set the RTC Center transform, if present.