@cesium/engine 26.1.0 → 26.3.0

package/Source/Scene/GltfLoader.js

@@ -14,6 +14,8 @@ import PrimitiveType from "../Core/PrimitiveType.js";
 import Quaternion from "../Core/Quaternion.js";
 import RuntimeError from "../Core/RuntimeError.js";
 import Sampler from "../Renderer/Sampler.js";
+import TextureMagnificationFilter from "../Renderer/TextureMagnificationFilter.js";
+import TextureMinificationFilter from "../Renderer/TextureMinificationFilter.js";
 import getAccessorByteStride from "./GltfPipeline/getAccessorByteStride.js";
 import getComponentReader from "./GltfPipeline/getComponentReader.js";
 import numberOfComponentsForType from "./GltfPipeline/numberOfComponentsForType.js";
@@ -61,6 +63,7 @@ const {
   Specular,
   Anisotropy,
   Clearcoat,
+  PlanarFill,
   LineStyle,
   Material,
   Vector,
@@ -1569,7 +1572,41 @@ function loadIndices(
   return indicesPlan;
 }
 
-function loadTexture(loader, textureInfo, frameState, samplerOverride) {
+/**
+ * Returns a copy of <code>sampler</code> with its minification and magnification
+ * filters replaced. Undefined filters keep the value already on the sampler, and
+ * every other property, in particular the wrap modes declared by the glTF, is
+ * carried over unchanged.
+ *
+ * @param {Sampler} sampler The sampler created from the glTF.
+ * @param {TextureMinificationFilter} [minificationFilter] The minification filter to apply instead of the one on <code>sampler</code>.
+ * @param {TextureMagnificationFilter} [magnificationFilter] The magnification filter to apply instead of the one on <code>sampler</code>.
+ * @returns {Sampler} A sampler using the given filters and the original wrap modes.
+ *
+ * @private
+ */
+function overrideSamplerFilters(
+  sampler,
+  minificationFilter,
+  magnificationFilter,
+) {
+  return new Sampler({
+    wrapR: sampler.wrapR,
+    wrapS: sampler.wrapS,
+    wrapT: sampler.wrapT,
+    minificationFilter: minificationFilter ?? sampler.minificationFilter,
+    magnificationFilter: magnificationFilter ?? sampler.magnificationFilter,
+    maximumAnisotropy: sampler.maximumAnisotropy,
+  });
+}
+
+function loadTexture(
+  loader,
+  textureInfo,
+  frameState,
+  minificationFilterOverride,
+  magnificationFilterOverride,
+) {
   const gltf = loader.gltfJson;
   const imageId = GltfLoaderUtil.getImageIdFromTexture({
     gltf: gltf,
@@ -1617,9 +1654,17 @@ function loadTexture(loader, textureInfo, frameState, samplerOverride) {
   // Save this finish callback by the loader index so it can be called
   // in process().
   loader._textureCallbacks[index] = () => {
-    textureReader.texture = textureLoader.texture;
-    if (defined(samplerOverride)) {
-      textureReader.texture.sampler = samplerOverride;
+    const texture = textureLoader.texture;
+    textureReader.texture = texture;
+    if (
+      defined(minificationFilterOverride) ||
+      defined(magnificationFilterOverride)
+    ) {
+      texture.sampler = overrideSamplerFilters(
+        texture.sampler,
+        minificationFilterOverride,
+        magnificationFilterOverride,
+      );
     }
   };
 
@@ -1787,6 +1832,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;
@@ -1833,6 +1895,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);
 
@@ -1889,6 +1952,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)) {
@@ -1989,7 +2057,10 @@ function loadFeatureIdTexture(
     loader,
     textureInfo,
     frameState,
-    Sampler.NEAREST, // Feature ID textures require nearest sampling
+    // Feature ID textures require nearest sampling. Only the filters are
+    // overridden so the wrap modes declared by the glTF are preserved.
+    TextureMinificationFilter.NEAREST,
+    TextureMagnificationFilter.NEAREST,
   );
 
   // Though the new channel index is more future-proof, this implementation
@@ -2024,7 +2095,10 @@ function loadFeatureIdTextureLegacy(
     loader,
     textureInfo,
     frameState,
-    Sampler.NEAREST, // Feature ID textures require nearest sampling
+    // Feature ID textures require nearest sampling. Only the filters are
+    // overridden so the wrap modes declared by the glTF are preserved.
+    TextureMinificationFilter.NEAREST,
+    TextureMagnificationFilter.NEAREST,
   );
 
   featureIdTexture.textureReader.channels = featureIds.channels;
@@ -2156,7 +2230,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,
     );
@@ -2188,7 +2262,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(
@@ -2200,7 +2277,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/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/HeightReference.js

@@ -28,7 +28,7 @@ const HeightReference = {
   RELATIVE_TO_GROUND: 2,
 
   /**
-   * The position is clamped to terain.
+   * The position is clamped to terrain.
    * @type {number}
    * @constant
    */

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/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) {

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

@@ -12,8 +12,10 @@ import defined from "../Core/defined.js";
 
 /** @import Cesium3DTile from "./Cesium3DTile.js"; */
 /** @import Cesium3DTileset from "./Cesium3DTileset.js"; */
+/** @import HeightReference from "./HeightReference.js"; */
 /** @import Rectangle from "../Core/Rectangle.js"; */
 /** @import Resource from "../Core/Resource.js"; */
+/** @import Scene from "./Scene.js"; */
 
 /**
  * A Mapbox Vector Tiles (MVT) data provider. Loads .mvt or .pbf tiles, converting tiles
@@ -23,6 +25,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 +38,13 @@ 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.
+   * @param {HeightReference} [options.heightReference] Drapes the decoded points, lines and polygons onto the
+   *   surfaces selected by the value: {@link HeightReference.CLAMP_TO_TERRAIN} drapes onto the globe,
+   *   {@link HeightReference.CLAMP_TO_3D_TILE} drapes onto 3D Tiles and models, and
+   *   {@link HeightReference.CLAMP_TO_GROUND} drapes onto both. Requires <code>options.scene</code>.
+   * @param {Scene} [options.scene] The scene the generated tileset is rendered in, required when
+   *   <code>options.heightReference</code> is a clamping value.
+   * @returns {Promise<MVTDataProvider>}
    */
   static async fromUrl(url, options) {
     return /** @type {Promise<MVTDataProvider>} */ (
@@ -49,6 +59,7 @@ class MVTDataProvider extends UrlTemplate3DTilesDataProvider {
    */
   _createTilesetLoadOptions() {
     return {
+      ...super._createTilesetLoadOptions(),
       skipLevelOfDetail: false,
       enablePick: true,
       featureIdLabel: "featureId_0",

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.

package/Source/Scene/Model/EdgeVisibilityPipelineStage.js

@@ -276,15 +276,17 @@ function generateEdgeFaceNormals(edgeIndices, edgeData, edgeVisibility) {
     // No silhouette edges in this primitive, the shader only checks normals for SILHOUETTE edges.
     return edgeFaceNormals;
   }
-  const silhouetteNormalsFloat = new Float32Array(raw.length * 3);
+  // raw is a packed typed array (x0,y0,z0, x1,y1,z1, ...) of float, byte, or
+  // short components. The vectors are normalized below, which cancels the
+  // quantization scale, so raw components can be used directly for all three.
+  const normalCount = raw.length / 3;
+  const silhouetteNormalsFloat = new Float32Array(raw.length);
   const scratchNormal = new Cartesian3();
 
-  for (let i = 0; i < raw.length; i++) {
-    const vec3 = raw[i];
-    // Signed byte → float: map [-128,127] → [-1,1]
-    scratchNormal.x = 2 * ((vec3.x + 128) / 255) - 1;
-    scratchNormal.y = 2 * ((vec3.y + 128) / 255) - 1;
-    scratchNormal.z = 2 * ((vec3.z + 128) / 255) - 1;
+  for (let i = 0; i < normalCount; i++) {
+    scratchNormal.x = raw[i * 3];
+    scratchNormal.y = raw[i * 3 + 1];
+    scratchNormal.z = raw[i * 3 + 2];
 
     if (Cartesian3.magnitudeSquared(scratchNormal) > 0) {
       Cartesian3.normalize(scratchNormal, scratchNormal);
@@ -609,7 +611,7 @@ function collectVertexColors(runtimePrimitive) {
  * @param {number} edgeOtherPosLocation Shader attribute location for the other endpoint position
  * @param {number} edgeOffsetLocation Shader attribute location for edge offset (-1 or +1)
  * @param {VertexColorInfo} [vertexColorInfo] Packed per-vertex colors (optional)
- * @param {Object} edgeVisibility Edge visibility extension object (may contain silhouetteNormals[])
+ * @param {Object} edgeVisibility Edge visibility extension object (may contain silhouetteNormals, a packed typed array of VEC3 components)
  * @param {Float32Array} edgeFaceNormals Packed face normals (6 floats per edge)
  * @param {Object} [cumDistAttribute] Cumulative distance attribute
  * @param {number} [edgeCumDistLocation] Cumulative distance location

package/Source/Scene/Model/I3dmLoader.js

@@ -407,7 +407,7 @@ function createInstances(loader, components, frameState) {
   const featureIdArray = new Float32Array(instancesLength);
 
   const instancePositions = Cartesian3.unpackArray(translationTypedArray);
-  let instancePosition = new Cartesian3();
+  let instancePosition;
 
   const instanceNormalRight = new Cartesian3();
   const instanceNormalUp = new Cartesian3();