@cesium/engine 26.1.0 → 26.2.0

package/Source/Scene/Globe.js

@@ -28,6 +28,7 @@ import QuadtreePrimitive from "./QuadtreePrimitive.js";
 import SceneMode from "./SceneMode.js";
 import ShadowMode from "./ShadowMode.js";
 import CesiumMath from "../Core/Math.js";
+import VectorProvider from "../Core/VectorProvider.js";
 
 /**
  * The globe rendered in the scene, including its terrain ({@link Globe#terrainProvider})
@@ -45,6 +46,9 @@ function Globe(ellipsoid) {
     ellipsoid: ellipsoid,
   });
   const imageryLayerCollection = new ImageryLayerCollection();
+  const vectorProvider = new VectorProvider({
+    tilingScheme: terrainProvider.tilingScheme,
+  });
 
   this._ellipsoid = ellipsoid;
   this._imageryLayerCollection = imageryLayerCollection;
@@ -57,12 +61,15 @@ function Globe(ellipsoid) {
       terrainProvider: terrainProvider,
       imageryLayers: imageryLayerCollection,
       surfaceShaderSet: this._surfaceShaderSet,
+      vectorProvider,
     }),
   });
 
   this._terrainProvider = terrainProvider;
   this._terrainProviderChanged = new Event();
 
+  this._vectorProvider = vectorProvider;
+
   this._undergroundColor = Color.clone(Color.BLACK);
   this._undergroundColorAlphaByDistance = new NearFarScalar(
     ellipsoid.maximumRadius / 1000.0,
@@ -515,6 +522,9 @@ Object.defineProperties(Globe.prototype, {
     set: function (value) {
       if (value !== this._terrainProvider) {
         this._terrainProvider = value;
+        if (defined(value)) {
+          this._vectorProvider.tilingScheme = value.tilingScheme;
+        }
         this._terrainProviderChanged.raiseEvent(value);
         if (defined(this._material)) {
           makeShadersDirty(this);
@@ -534,6 +544,16 @@ Object.defineProperties(Globe.prototype, {
       return this._terrainProviderChanged;
     },
   },
+  /**
+   * @memberof Globe.prototype
+   * @type {VectorProvider}
+   * @ignore
+   */
+  vectorProvider: {
+    get: function () {
+      return this._vectorProvider;
+    },
+  },
   /**
    * Gets an event that's raised when the length of the tile load queue has changed since the last render frame.  When the load queue is empty,
    * all terrain and imagery for the current view have been loaded.  The event passes the new length of the tile load queue.

package/Source/Scene/GlobeDepth.js

@@ -2,6 +2,7 @@ import BoundingRectangle from "../Core/BoundingRectangle.js";
 import Color from "../Core/Color.js";
 import defined from "../Core/defined.js";
 import destroyObject from "../Core/destroyObject.js";
+import PixelFormat from "../Core/PixelFormat.js";
 import ClearCommand from "../Renderer/ClearCommand.js";
 import FramebufferManager from "../Renderer/FramebufferManager.js";
 import PixelDatatype from "../Renderer/PixelDatatype.js";
@@ -21,6 +22,7 @@ import StencilOperation from "./StencilOperation.js";
  */
 function GlobeDepth() {
   this._picking = false;
+  this._snapping = false;
   this._numSamples = 1;
   this._tempCopyDepthTexture = undefined;
 
@@ -28,6 +30,16 @@ function GlobeDepth() {
     depthStencil: true,
     supportsDepthTexture: true,
   });
+  // Float twin of the pick color framebuffer, used during a snapping pass
+  // (see Scene#snap). RGBA32F so each pixel can carry the snap payload
+  // (uint32 pick ID, isEdge flag, eye-space depth). GPU resources are only
+  // allocated on first use (FramebufferManager allocates lazily in update).
+  this._snapColorFramebuffer = new FramebufferManager({
+    depthStencil: true,
+    supportsDepthTexture: true,
+    pixelDatatype: PixelDatatype.FLOAT,
+    pixelFormat: PixelFormat.RGBA,
+  });
   this._outputFramebuffer = new FramebufferManager({
     depthStencil: true,
     supportsDepthTexture: true,
@@ -61,6 +73,9 @@ function GlobeDepth() {
 Object.defineProperties(GlobeDepth.prototype, {
   colorFramebufferManager: {
     get: function () {
+      if (this._snapping) {
+        return this._snapColorFramebuffer;
+      }
       return this._picking
         ? this._pickColorFramebuffer
         : this._outputFramebuffer;
@@ -84,6 +99,14 @@ Object.defineProperties(GlobeDepth.prototype, {
       this._picking = value;
     },
   },
+  snapping: {
+    get: function () {
+      return this._snapping;
+    },
+    set: function (value) {
+      this._snapping = value;
+    },
+  },
 });
 
 function updateCopyCommands(globeDepth, context, width, height, passState) {
@@ -260,7 +283,9 @@ GlobeDepth.prototype.update = function (
       : PixelDatatype.FLOAT
     : PixelDatatype.UNSIGNED_BYTE;
   this._numSamples = numSamples;
-  if (this.picking) {
+  if (this.snapping) {
+    this._snapColorFramebuffer.update(context, width, height);
+  } else if (this.picking) {
     this._pickColorFramebuffer.update(context, width, height);
   } else {
     this._outputFramebuffer.update(
@@ -377,6 +402,7 @@ GlobeDepth.prototype.isDestroyed = function () {
 
 GlobeDepth.prototype.destroy = function () {
   this._pickColorFramebuffer.destroy();
+  this._snapColorFramebuffer.destroy();
   this._outputFramebuffer.destroy();
   this._copyDepthFramebuffer.destroy();
   this._tempCopyDepthFramebuffer.destroy();

package/Source/Scene/GlobeSurfaceShaderSet.js

@@ -4,6 +4,7 @@ import defined from "../Core/defined.js";
 import destroyObject from "../Core/destroyObject.js";
 import TerrainQuantization from "../Core/TerrainQuantization.js";
 import ShaderProgram from "../Renderer/ShaderProgram.js";
+import VectorCommon from "../Shaders/VectorCommon.js";
 import getClippingFunction from "./getClippingFunction.js";
 import SceneMode from "./SceneMode.js";
 
@@ -81,7 +82,7 @@ class GlobeSurfaceShader {
  * @property {boolean} [hasExaggeration]
  * @property {boolean} [showUndergroundColor]
  * @property {boolean} [translucent]
- * @ignore
+ * @private
  */
 
 /**
@@ -138,6 +139,8 @@ class GlobeSurfaceShaderSet {
     const hasExaggeration = options.hasExaggeration;
     const showUndergroundColor = options.showUndergroundColor;
     const translucent = options.translucent;
+    const vectorData = surfaceTile.vectorData;
+    const hasVectorLayer = vectorData?.show;
 
     let quantization = 0;
     let quantizationDefine = "";
@@ -201,7 +204,8 @@ class GlobeSurfaceShaderSet {
         (+showUndergroundColor << 30) |
         (+translucent << 31)) >>>
         0) +
-      (applyDayNightAlpha ? 0x100000000 : 0);
+      (applyDayNightAlpha ? 0x100000000 : 0) +
+      (hasVectorLayer ? 0x200000000 : 0);
 
     let currentClippingShaderState = 0;
     // @ts-expect-error Missing types.
@@ -392,6 +396,12 @@ class GlobeSurfaceShaderSet {
         vs.defines.push("EXAGGERATION");
       }
 
+      if (hasVectorLayer) {
+        vs.defines.push("HAS_VECTOR_LAYER");
+        fs.defines.push("HAS_VECTOR_LAYER");
+        fs.sources.unshift(VectorCommon); // before GlobeFS.
+      }
+
       let computeDayColor =
         "\
       vec4 computeDayColor(vec4 initialColor, vec3 textureCoordinates, float nightBlend)\n\

package/Source/Scene/GlobeSurfaceTile.js

@@ -9,6 +9,7 @@ import RequestState from "../Core/RequestState.js";
 import RequestType from "../Core/RequestType.js";
 import TerrainEncoding from "../Core/TerrainEncoding.js";
 import TileProviderError from "../Core/TileProviderError.js";
+import VectorPipeline from "../Core/VectorPipeline.js";
 import Buffer from "../Renderer/Buffer.js";
 import BufferUsage from "../Renderer/BufferUsage.js";
 import PixelDatatype from "../Renderer/PixelDatatype.js";
@@ -36,6 +37,7 @@ import TerrainState from "./TerrainState.js";
 /** @import TerrainProvider from "../Core/TerrainProvider.js"; */
 /** @import TileBoundingRegion from "./TileBoundingRegion.js"; */
 /** @import TileImagery from "./TileImagery.js"; */
+/** @import VectorProvider, { VectorTileData } from "../Core/VectorProvider.js"; */
 
 /**
  * Contains additional information about a {@link QuadtreeTile} of the globe's surface, and
@@ -62,6 +64,9 @@ class GlobeSurfaceTile {
     /** @type {HeightmapTerrainData} */
     this.terrainData = undefined;
 
+    /** @type {VectorTileData} */
+    this.vectorData = undefined;
+
     /** @type {VertexArray} */
     this.vertexArray = undefined;
 
@@ -159,6 +164,11 @@ class GlobeSurfaceTile {
       this.waterMaskTexture = undefined;
     }
 
+    if (defined(this.vectorData)) {
+      VectorPipeline.freeResources(this.vectorData);
+      this.vectorData = undefined;
+    }
+
     this.terrainData = undefined;
 
     this.terrainState = TerrainState.UNLOADED;
@@ -184,26 +194,37 @@ class GlobeSurfaceTile {
   /**
    * @param {QuadtreeTile} tile
    * @param {TerrainProvider} terrainProvider
+   * @param {VectorProvider} vectorProvider
    * @param {ImageryLayerCollection} imageryLayerCollection
    */
-  static initialize(tile, terrainProvider, imageryLayerCollection) {
-    let surfaceTile = tile.data;
-    if (!defined(surfaceTile)) {
-      surfaceTile = tile.data = new GlobeSurfaceTile();
+  static initialize(
+    tile,
+    terrainProvider,
+    vectorProvider,
+    imageryLayerCollection,
+  ) {
+    if (!defined(tile.data)) {
+      tile.data = new GlobeSurfaceTile();
     }
 
     if (tile.state === QuadtreeTileLoadState.START) {
-      prepareNewTile(tile, terrainProvider, imageryLayerCollection);
+      prepareNewTile(
+        tile,
+        terrainProvider,
+        vectorProvider,
+        imageryLayerCollection,
+      );
       tile.state = QuadtreeTileLoadState.LOADING;
     }
   }
 
   /**
-   * @param {*} tile
+   * @param {QuadtreeTile} tile
    * @param {FrameState} frameState
    * @param {TerrainProvider} terrainProvider
+   * @param {VectorProvider} vectorProvider
    * @param {ImageryLayerCollection} imageryLayerCollection
-   * @param {*} quadtree
+   * @param {QuadtreePrimitive} quadtree
    * @param {*} vertexArraysToDestroy
    * @param {*} terrainOnly
    */
@@ -211,12 +232,18 @@ class GlobeSurfaceTile {
     tile,
     frameState,
     terrainProvider,
+    vectorProvider,
     imageryLayerCollection,
     quadtree,
     vertexArraysToDestroy,
     terrainOnly,
   ) {
-    GlobeSurfaceTile.initialize(tile, terrainProvider, imageryLayerCollection);
+    GlobeSurfaceTile.initialize(
+      tile,
+      terrainProvider,
+      vectorProvider,
+      imageryLayerCollection,
+    );
 
     const surfaceTile = tile.data;
 
@@ -225,6 +252,7 @@ class GlobeSurfaceTile {
         tile,
         frameState,
         terrainProvider,
+        vectorProvider,
         imageryLayerCollection,
         quadtree,
         vertexArraysToDestroy,
@@ -604,10 +632,16 @@ function toggleGeodeticSurfaceNormals(
 /**
  * @param {QuadtreeTile} tile
  * @param {TerrainProvider} terrainProvider
+ * @param {VectorProvider} vectorProvider
  * @param {ImageryLayerCollection} imageryLayerCollection
  * @ignore
  */
-function prepareNewTile(tile, terrainProvider, imageryLayerCollection) {
+function prepareNewTile(
+  tile,
+  terrainProvider,
+  vectorProvider,
+  imageryLayerCollection,
+) {
   /** @type {boolean} */
   let available = terrainProvider.getTileDataAvailable(
     // @ts-expect-error Missing types.
@@ -630,8 +664,9 @@ function prepareNewTile(tile, terrainProvider, imageryLayerCollection) {
     }
   }
 
+  const surfaceTile = /** @type {GlobeSurfaceTile} */ (tile.data);
+
   if (available === false) {
-    const surfaceTile = /** @type {GlobeSurfaceTile} */ (tile.data);
     // This tile is not available, so mark it failed so we start upsampling right away.
     surfaceTile.terrainState = TerrainState.FAILED;
   }
@@ -650,6 +685,7 @@ function prepareNewTile(tile, terrainProvider, imageryLayerCollection) {
  * @param {QuadtreeTile} tile
  * @param {FrameState} frameState
  * @param {TerrainProvider} terrainProvider
+ * @param {VectorProvider} vectorProvider
  * @param {ImageryLayerCollection} imageryLayerCollection
  * @param {QuadtreePrimitive} quadtree
  * @param {*} vertexArraysToDestroy
@@ -659,6 +695,7 @@ function processTerrainStateMachine(
   tile,
   frameState,
   terrainProvider,
+  vectorProvider,
   imageryLayerCollection,
   quadtree,
   vertexArraysToDestroy,
@@ -684,6 +721,7 @@ function processTerrainStateMachine(
         parent,
         frameState,
         terrainProvider,
+        vectorProvider,
         imageryLayerCollection,
         quadtree,
         vertexArraysToDestroy,

package/Source/Scene/GlobeSurfaceTileProvider.js

@@ -63,6 +63,7 @@ import TileSelectionResult from "./TileSelectionResult.js";
 /** @import TerrainMesh from "../Core/TerrainMesh.js"; */
 /** @import TerrainProvider from "../Core/TerrainProvider.js"; */
 /** @import TilingScheme from "../Core/TilingScheme.js"; */
+/** @import VectorProvider, { VectorTileData } from "../Core/VectorProvider.js"; */
 /** @import { GlobeSurfaceShaderSetOptions } from "./GlobeSurfaceShaderSet.js"; */
 
 /**
@@ -77,6 +78,7 @@ class GlobeSurfaceTileProvider {
    * @param {TerrainProvider} options.terrainProvider The terrain provider that describes the surface geometry.
    * @param {ImageryLayerCollection} options.imageryLayers The collection of imagery layers describing the shading of the surface.
    * @param {GlobeSurfaceShaderSet} options.surfaceShaderSet The set of shaders used to render the surface.
+   * @param {VectorProvider} options.vectorProvider
    */
   constructor(options) {
     //>>includeStart('debug', pragmas.debug);
@@ -89,6 +91,8 @@ class GlobeSurfaceTileProvider {
       throw new DeveloperError("options.imageryLayers is required.");
     } else if (!defined(options.surfaceShaderSet)) {
       throw new DeveloperError("options.surfaceShaderSet is required.");
+    } else if (!defined(options.vectorProvider)) {
+      throw new DeveloperError("options.vectorProvider is required.");
     }
     //>>includeEnd('debug');
 
@@ -131,6 +135,7 @@ class GlobeSurfaceTileProvider {
 
     this._quadtree = undefined;
     this._terrainProvider = options.terrainProvider;
+    this._vectorProvider = options.vectorProvider;
     this._imageryLayers = options.imageryLayers;
     this._surfaceShaderSet = options.surfaceShaderSet;
 
@@ -311,6 +316,11 @@ class GlobeSurfaceTileProvider {
     }
   }
 
+  /** @type {VectorProvider} */
+  get vectorProvider() {
+    return this._vectorProvider;
+  }
+
   /**
    * The {@link ClippingPlaneCollection} used to selectively disable rendering.
    *
@@ -371,6 +381,35 @@ class GlobeSurfaceTileProvider {
       );
     }
 
+    // Record regions dirtied by changed collections, re-bake overlapping
+    // tiles, and build vector data for new surface tiles.
+    const vectorProvider = this._vectorProvider;
+    vectorProvider.update();
+    this._quadtree.forEachRenderedTile(
+      /** @param {QuadtreeTile} tile */
+      (tile) => {
+        const surfaceTile = /** @type {GlobeSurfaceTile} */ (tile.data);
+
+        if (defined(surfaceTile.vectorData)) {
+          surfaceTile.vectorData = vectorProvider.updateTileData(
+            tile.x,
+            tile.y,
+            tile.level,
+            frameState.context,
+            surfaceTile.vectorData,
+          );
+        } else {
+          surfaceTile.vectorData = vectorProvider.requestTileData(
+            tile.x,
+            tile.y,
+            tile.level,
+            frameState.context,
+          );
+        }
+      },
+    );
+    vectorProvider.makeClean();
+
     // Add credits for terrain and imagery providers.
     updateCredits(this, frameState);
 
@@ -609,6 +648,7 @@ class GlobeSurfaceTileProvider {
       tile,
       frameState,
       this.terrainProvider,
+      this.vectorProvider,
       this._imageryLayers,
       this.quadtree,
       this._vertexArraysToDestroy,
@@ -635,6 +675,7 @@ class GlobeSurfaceTileProvider {
           tile,
           frameState,
           this.terrainProvider,
+          this.vectorProvider,
           this._imageryLayers,
           this.quadtree,
           this._vertexArraysToDestroy,
@@ -1915,6 +1956,52 @@ function createTileUniformMap(frameState, globeSurfaceTileProvider) {
     u_vertexShadowDarkness: function () {
       return this.properties.vertexShadowDarkness;
     },
+    u_vectorSegmentTexture: function () {
+      return (
+        this.properties.vectorSegmentTexture ??
+        frameState.context.defaultTexture
+      );
+    },
+    u_vectorWidthTexture: function () {
+      return (
+        this.properties.vectorWidthTexture ?? frameState.context.defaultTexture
+      );
+    },
+    u_vectorColorTexture: function () {
+      return (
+        this.properties.vectorColorTexture ?? frameState.context.defaultTexture
+      );
+    },
+    u_vectorSegmentPrimitiveIndicesTexture: function () {
+      return (
+        this.properties.vectorSegmentPrimitiveIndicesTexture ??
+        frameState.context.defaultTexture
+      );
+    },
+    u_vectorGridCellIndicesTexture: function () {
+      return (
+        this.properties.vectorGridCellIndicesTexture ??
+        frameState.context.defaultTexture
+      );
+    },
+    u_vectorPolygonEdgeTexture: function () {
+      return (
+        this.properties.vectorPolygonEdgeTexture ??
+        frameState.context.defaultTexture
+      );
+    },
+    u_vectorPolygonEdgePrimitiveIndicesTexture: function () {
+      return (
+        this.properties.vectorPolygonEdgePrimitiveIndicesTexture ??
+        frameState.context.defaultTexture
+      );
+    },
+    u_vectorPolygonGridCellIndicesTexture: function () {
+      return (
+        this.properties.vectorPolygonGridCellIndicesTexture ??
+        frameState.context.defaultTexture
+      );
+    },
 
     // make a separate object so that changes to the properties are seen on
     // derived commands that combine another uniform map with this one.
@@ -1977,6 +2064,15 @@ function createTileUniformMap(frameState, globeSurfaceTileProvider) {
       undergroundColorAlphaByDistance: new Cartesian4(),
       lambertDiffuseMultiplier: 0.0,
       vertexShadowDarkness: 0.0,
+
+      vectorSegmentTexture: undefined,
+      vectorWidthTexture: undefined,
+      vectorColorTexture: undefined,
+      vectorSegmentPrimitiveIndicesTexture: undefined,
+      vectorGridCellIndicesTexture: undefined,
+      vectorPolygonEdgeTexture: undefined,
+      vectorPolygonEdgePrimitiveIndicesTexture: undefined,
+      vectorPolygonGridCellIndicesTexture: undefined,
     },
   };
 
@@ -2916,10 +3012,32 @@ function addDrawCommandsForTile(tileProvider, tile, frameState) {
       uniformMapProperties.clippingPlanesEdgeWidth = clippingPlanes.edgeWidth;
     }
 
+    // update vector collections clamped to terrain
+    const vectorData = surfaceTile.vectorData;
+    if (defined(vectorData)) {
+      uniformMapProperties.vectorSegmentTexture =
+        vectorData.polylineSegmentTexture;
+      uniformMapProperties.vectorWidthTexture = vectorData.widthTexture;
+      uniformMapProperties.vectorColorTexture = vectorData.colorTexture;
+      uniformMapProperties.vectorSegmentPrimitiveIndicesTexture =
+        vectorData.polylineSegmentPrimitiveIndicesTexture;
+      uniformMapProperties.vectorGridCellIndicesTexture =
+        vectorData.polylineGridCellIndicesTexture;
+      uniformMapProperties.vectorPolygonEdgeTexture =
+        vectorData.polygonEdgeTexture;
+      uniformMapProperties.vectorPolygonEdgePrimitiveIndicesTexture =
+        vectorData.polygonEdgePrimitiveIndicesTexture;
+      uniformMapProperties.vectorPolygonGridCellIndicesTexture =
+        vectorData.polygonGridCellIndicesTexture;
+    }
+
     // update clipping polygons
     const clippingPolygons = tileProvider._clippingPolygons;
     const clippingPolygonsEnabled =
-      defined(clippingPolygons) && clippingPolygons.enabled && tile.isClipped;
+      defined(clippingPolygons) &&
+      clippingPolygons.enabled &&
+      clippingPolygons.length > 0 &&
+      tile.isClipped;
 
     surfaceShaderSetOptions.numberOfDayTextures = numberOfDayTextures;
     surfaceShaderSetOptions.applyBrightness = applyBrightness;
@@ -2969,7 +3087,7 @@ function addDrawCommandsForTile(tileProvider, tile, frameState) {
       }
     }
 
-    let boundingVolume = command.boundingVolume;
+    const boundingVolume = command.boundingVolume;
     const orientedBoundingBox = command.orientedBoundingBox;
 
     if (frameState.mode !== SceneMode.SCENE3D) {
@@ -2988,7 +3106,7 @@ function addDrawCommandsForTile(tileProvider, tile, frameState) {
       );
 
       if (frameState.mode === SceneMode.MORPHING) {
-        boundingVolume = BoundingSphere.union(
+        BoundingSphere.union(
           // @ts-expect-error Missing types.
           tileBoundingRegion.boundingSphere,
           boundingVolume,

package/Source/Scene/GltfLoader.js

@@ -61,6 +61,7 @@ const {
   Specular,
   Anisotropy,
   Clearcoat,
+  PlanarFill,
   LineStyle,
   Material,
   Vector,
@@ -1787,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;
@@ -1833,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);
 
@@ -1889,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)) {
@@ -2156,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,
     );
@@ -2188,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(
@@ -2200,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/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 {