@cesium/engine 13.0.0 → 14.0.0

package/Source/Scene/GltfVertexBufferLoader.js

@@ -26,6 +26,7 @@ import ResourceLoaderState from "./ResourceLoaderState.js";
  * @param {Resource} options.gltfResource The {@link Resource} containing the glTF.
  * @param {Resource} options.baseResource The {@link Resource} that paths in the glTF JSON are relative to.
  * @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 {string} [options.attributeSemantic] The attribute semantic, e.g. POSITION or NORMAL.
  * @param {number} [options.accessorId] The accessor id.
@@ -47,6 +48,7 @@ function GltfVertexBufferLoader(options) {
   const gltfResource = options.gltfResource;
   const baseResource = options.baseResource;
   const bufferViewId = options.bufferViewId;
+  const primitive = options.primitive;
   const draco = options.draco;
   const attributeSemantic = options.attributeSemantic;
   const accessorId = options.accessorId;
@@ -67,6 +69,7 @@ function GltfVertexBufferLoader(options) {
   }
 
   const hasBufferViewId = defined(bufferViewId);
+  const hasPrimitive = defined(primitive);
   const hasDraco = hasDracoCompression(draco, attributeSemantic);
   const hasAttributeSemantic = defined(attributeSemantic);
   const hasAccessorId = defined(accessorId);
@@ -89,7 +92,14 @@ function GltfVertexBufferLoader(options) {
     );
   }
 
+  if (hasDraco && !hasPrimitive) {
+    throw new DeveloperError(
+      "When options.draco is defined options.primitive must also be defined.",
+    );
+  }
+
   if (hasDraco) {
+    Check.typeOf.object("options.primitive", primitive);
     Check.typeOf.object("options.draco", draco);
     Check.typeOf.string("options.attributeSemantic", attributeSemantic);
     Check.typeOf.number("options.accessorId", accessorId);
@@ -101,6 +111,7 @@ function GltfVertexBufferLoader(options) {
   this._baseResource = baseResource;
   this._gltf = gltf;
   this._bufferViewId = bufferViewId;
+  this._primitive = primitive;
   this._draco = draco;
   this._attributeSemantic = attributeSemantic;
   this._accessorId = accessorId;
@@ -265,6 +276,7 @@ async function loadFromDraco(vertexBufferLoader) {
   try {
     const dracoLoader = resourceCache.getDracoLoader({
       gltf: vertexBufferLoader._gltf,
+      primitive: vertexBufferLoader._primitive,
       draco: vertexBufferLoader._draco,
       gltfResource: vertexBufferLoader._gltfResource,
       baseResource: vertexBufferLoader._baseResource,
@@ -467,6 +479,7 @@ GltfVertexBufferLoader.prototype.unload = function () {
   this._typedArray = undefined;
   this._buffer = undefined;
   this._gltf = undefined;
+  this._primitive = undefined;
 };
 
 export default GltfVertexBufferLoader;

package/Source/Scene/ITwinData.js

@@ -4,6 +4,9 @@ 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";
+import DeveloperError from "../Core/DeveloperError.js";
 
 /**
  * Methods for loading iTwin platform data into CesiumJS
@@ -86,6 +89,8 @@ ITwinData.createTilesetFromIModelId = async function (iModelId, options) {
  * @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,
@@ -135,4 +140,115 @@ ITwinData.createTilesetForRealityDataId = async function (
   });
 };
 
+/**
+ * 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 (
+  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);
+};
+
+/**
+ * Load data from the Geospatial Features API as GeoJSON.
+ *
+ * @param {string} iTwinId The id of the iTwin to load data from
+ * @param {string} collectionId The id of the data collection to load
+ * @param {number} [limit=10000] number of items per page, must be between 1 and 10,000 inclusive
+ * @returns {Promise<GeoJsonDataSource>}
+ */
+ITwinData.loadGeospatialFeatures = async function (
+  iTwinId,
+  collectionId,
+  limit,
+) {
+  //>>includeStart('debug', pragmas.debug);
+  Check.typeOf.string("iTwinId", iTwinId);
+  Check.typeOf.string("collectionId", collectionId);
+  if (defined(limit)) {
+    Check.typeOf.number("limit", limit);
+    Check.typeOf.number.lessThanOrEquals("limit", limit, 10000);
+    Check.typeOf.number.greaterThanOrEquals("limit", limit, 1);
+  }
+  if (!defined(ITwinPlatform.defaultAccessToken)) {
+    throw new DeveloperError("Must set ITwinPlatform.defaultAccessToken first");
+  }
+  //>>includeEnd('debug')
+
+  const pageLimit = limit ?? 10000;
+
+  const tilesetUrl = `${ITwinPlatform.apiEndpoint}geospatial-features/itwins/${iTwinId}/ogc/collections/${collectionId}/items`;
+
+  const resource = new Resource({
+    url: tilesetUrl,
+    headers: {
+      Authorization: `Bearer ${ITwinPlatform.defaultAccessToken}`,
+      Accept: "application/vnd.bentley.itwin-platform.v1+json",
+    },
+    queryParameters: {
+      limit: pageLimit,
+      client: "CesiumJS",
+    },
+  });
+
+  return GeoJsonDataSource.load(resource);
+};
+
 export default ITwinData;

package/Source/Scene/ImageryLayer.js

@@ -511,7 +511,7 @@ ImageryLayer.DEFAULT_APPLY_COLOR_TO_ALPHA_THRESHOLD = 0.004;
  * Create a new imagery layer from an asynchronous imagery provider. The layer will handle any asynchronous loads or errors, and begin rendering the imagery layer once ready.
  *
  * @param {Promise<ImageryProvider>} imageryProviderPromise A promise which resolves to a imagery provider
- * @param {ImageryLayer.ConstructorOptions} options An object describing initialization options
+ * @param {ImageryLayer.ConstructorOptions} [options] An object describing initialization options
  * @returns {ImageryLayer} The created imagery layer.
  *
  * @example

package/Source/Scene/Label.js

@@ -1364,7 +1364,7 @@ Label.filterUnsupportedCharacters = function (text) {
  * Determines if this label equals another label.  Labels are equal if all their properties
  * are equal.  Labels in different collections can be equal.
  *
- * @param {Label} other The label to compare for equality.
+ * @param {Label} [other] The label to compare for equality.
  * @returns {boolean} <code>true</code> if the labels are equal; otherwise, <code>false</code>.
  */
 Label.prototype.equals = function (other) {

package/Source/Scene/LabelCollection.js

@@ -68,7 +68,6 @@ function createGlyphCanvas(
   outlineColor,
   outlineWidth,
   style,
-  verticalOrigin,
 ) {
   writeTextToCanvasParameters.font = font;
   writeTextToCanvasParameters.fillColor = fillColor;
@@ -77,15 +76,6 @@ function createGlyphCanvas(
   // Setting the padding to something bigger is necessary to get enough space for the outlining.
   writeTextToCanvasParameters.padding = SDFSettings.PADDING;
 
-  if (verticalOrigin === VerticalOrigin.CENTER) {
-    writeTextToCanvasParameters.textBaseline = "middle";
-  } else if (verticalOrigin === VerticalOrigin.TOP) {
-    writeTextToCanvasParameters.textBaseline = "top";
-  } else {
-    // VerticalOrigin.BOTTOM and VerticalOrigin.BASELINE
-    writeTextToCanvasParameters.textBaseline = "bottom";
-  }
-
   writeTextToCanvasParameters.fill =
     style === LabelStyle.FILL || style === LabelStyle.FILL_AND_OUTLINE;
   writeTextToCanvasParameters.stroke =
@@ -211,7 +201,6 @@ function rebindAllGlyphs(labelCollection, label) {
         Color.WHITE,
         0.0,
         LabelStyle.FILL,
-        verticalOrigin,
       );
 
       glyphTextureInfo = new GlyphTextureInfo(

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/Multiple3DTileContent.js

@@ -6,7 +6,6 @@ import Request from "../Core/Request.js";
 import RequestScheduler from "../Core/RequestScheduler.js";
 import RequestState from "../Core/RequestState.js";
 import RequestType from "../Core/RequestType.js";
-import RuntimeError from "../Core/RuntimeError.js";
 import Cesium3DContentGroup from "./Cesium3DContentGroup.js";
 import Cesium3DTileContentType from "./Cesium3DTileContentType.js";
 import Cesium3DTileContentFactory from "./Cesium3DTileContentFactory.js";
@@ -52,6 +51,11 @@ function Multiple3DTileContent(tileset, tile, tilesetResource, contentsJson) {
   // used to help short-circuit computations after a tile was canceled.
   this._cancelCount = 0;
 
+  // The number of contents that turned out to be external tilesets
+  // in createInnerContent. When all contents are external tilesets,
+  // then tile.hasRenderableContent will become `false`
+  this._externalTilesetCount = 0;
+
   const contentCount = this._innerContentHeaders.length;
   this._arrayFetchPromises = new Array(contentCount);
   this._requests = new Array(contentCount);
@@ -505,6 +509,16 @@ async function createInnerContents(multipleContents) {
   const contents = await Promise.all(promises);
   multipleContents._contentsCreated = true;
   multipleContents._contents = contents.filter(defined);
+
+  // If each content is an external tileset, then the tile
+  // itself does not have any renderable content
+  if (
+    multipleContents._externalTilesetCount === multipleContents._contents.length
+  ) {
+    const tile = multipleContents._tile;
+    tile.hasRenderableContent = false;
+  }
+
   return contents;
 }
 
@@ -518,10 +532,13 @@ async function createInnerContent(multipleContents, arrayBuffer, index) {
   try {
     const preprocessed = preprocess3DTileContent(arrayBuffer);
 
+    const tileset = multipleContents._tileset;
+    const resource = multipleContents._innerContentResources[index];
+    const tile = multipleContents._tile;
+
     if (preprocessed.contentType === Cesium3DTileContentType.EXTERNAL_TILESET) {
-      throw new RuntimeError(
-        "External tilesets are disallowed inside multiple contents",
-      );
+      multipleContents._externalTilesetCount++;
+      tile.hasTilesetContent = true;
     }
 
     multipleContents._disableSkipLevelOfDetail =
@@ -529,10 +546,6 @@ async function createInnerContent(multipleContents, arrayBuffer, index) {
       preprocessed.contentType === Cesium3DTileContentType.GEOMETRY ||
       preprocessed.contentType === Cesium3DTileContentType.VECTOR;
 
-    const tileset = multipleContents._tileset;
-    const resource = multipleContents._innerContentResources[index];
-    const tile = multipleContents._tile;
-
     let content;
     const contentFactory = Cesium3DTileContentFactory[preprocessed.contentType];
     if (defined(preprocessed.binaryPayload)) {

package/Source/Scene/PointPrimitive.js

@@ -665,7 +665,7 @@ PointPrimitive.getScreenSpaceBoundingBox = function (
  * Determines if this point equals another point.  Points are equal if all their properties
  * are equal.  Points in different collections can be equal.
  *
- * @param {PointPrimitive} other The point to compare for equality.
+ * @param {PointPrimitive} [other] The point to compare for equality.
  * @returns {boolean} <code>true</code> if the points are equal; otherwise, <code>false</code>.
  */
 PointPrimitive.prototype.equals = function (other) {

package/Source/Scene/ResourceCache.js

@@ -345,6 +345,7 @@ ResourceCache.getBufferViewLoader = function (options) {
  *
  * @param {object} options Object with the following properties:
  * @param {object} options.gltf The glTF JSON.
+ * @param {object} options.primitive The primitive containing the Draco extension.
  * @param {object} options.draco The Draco extension object.
  * @param {Resource} options.gltfResource The {@link Resource} containing the glTF.
  * @param {Resource} options.baseResource The {@link Resource} that paths in the glTF JSON are relative to.
@@ -354,10 +355,11 @@ ResourceCache.getBufferViewLoader = function (options) {
  */
 ResourceCache.getDracoLoader = function (options) {
   options = defaultValue(options, defaultValue.EMPTY_OBJECT);
-  const { gltf, draco, gltfResource, baseResource } = options;
+  const { gltf, primitive, draco, gltfResource, baseResource } = options;
 
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.object("options.gltf", gltf);
+  Check.typeOf.object("options.primitive", primitive);
   Check.typeOf.object("options.draco", draco);
   Check.typeOf.object("options.gltfResource", gltfResource);
   Check.typeOf.object("options.baseResource", baseResource);
@@ -378,6 +380,7 @@ ResourceCache.getDracoLoader = function (options) {
   dracoLoader = new GltfDracoLoader({
     resourceCache: ResourceCache,
     gltf: gltf,
+    primitive: primitive,
     draco: draco,
     gltfResource: gltfResource,
     baseResource: baseResource,
@@ -396,6 +399,7 @@ ResourceCache.getDracoLoader = function (options) {
  * @param {Resource} options.baseResource The {@link Resource} that paths in the glTF JSON are relative to.
  * @param {FrameState} options.frameState The frame state.
  * @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 {string} [options.attributeSemantic] The attribute semantic, e.g. POSITION or NORMAL.
  * @param {number} [options.accessorId] The accessor ID.
@@ -418,6 +422,7 @@ ResourceCache.getVertexBufferLoader = function (options) {
     baseResource,
     frameState,
     bufferViewId,
+    primitive,
     draco,
     attributeSemantic,
     accessorId,
@@ -439,6 +444,7 @@ ResourceCache.getVertexBufferLoader = function (options) {
   }
 
   const hasBufferViewId = defined(bufferViewId);
+  const hasPrimitive = defined(primitive);
   const hasDraco = hasDracoCompression(draco, attributeSemantic);
   const hasAttributeSemantic = defined(attributeSemantic);
   const hasAccessorId = defined(accessorId);
@@ -461,6 +467,12 @@ ResourceCache.getVertexBufferLoader = function (options) {
     );
   }
 
+  if (hasDraco && !hasPrimitive) {
+    throw new DeveloperError(
+      "When options.draco is defined options.primitive must also be defined.",
+    );
+  }
+
   if (hasDraco) {
     Check.typeOf.object("options.draco", draco);
     Check.typeOf.string("options.attributeSemantic", attributeSemantic);
@@ -492,6 +504,7 @@ ResourceCache.getVertexBufferLoader = function (options) {
     gltfResource: gltfResource,
     baseResource: baseResource,
     bufferViewId: bufferViewId,
+    primitive: primitive,
     draco: draco,
     attributeSemantic: attributeSemantic,
     accessorId: accessorId,
@@ -522,6 +535,7 @@ function hasDracoCompression(draco, semantic) {
  * @param {Resource} options.gltfResource The {@link Resource} containing the glTF.
  * @param {Resource} options.baseResource The {@link Resource} that paths in the glTF JSON are relative to.
  * @param {FrameState} options.frameState The frame state.
+ * @param {object} [options.primitive] The primitive containing the Draco extension.
  * @param {object} [options.draco] The Draco extension object.
  * @param {boolean} [options.asynchronous=true] Determines if WebGL resource creation will be spread out over several frames or block until all WebGL resources are created.
  * @param {boolean} [options.loadBuffer=false] Load index buffer as a GPU index buffer.
@@ -537,6 +551,7 @@ ResourceCache.getIndexBufferLoader = function (options) {
     gltfResource,
     baseResource,
     frameState,
+    primitive,
     draco,
     asynchronous = true,
     loadBuffer = false,
@@ -578,6 +593,7 @@ ResourceCache.getIndexBufferLoader = function (options) {
     accessorId: accessorId,
     gltfResource: gltfResource,
     baseResource: baseResource,
+    primitive: primitive,
     draco: draco,
     cacheKey: cacheKey,
     asynchronous: asynchronous,

package/Source/Scene/VoxelPrimitive.js

@@ -25,6 +25,7 @@ import CustomShader from "./Model/CustomShader.js";
 import Cartographic from "../Core/Cartographic.js";
 import Ellipsoid from "../Core/Ellipsoid.js";
 import VerticalExaggeration from "../Core/VerticalExaggeration.js";
+import Cesium3DTilesetStatistics from "./Cesium3DTilesetStatistics.js";
 
 /**
  * A primitive that renders voxel data from a {@link VoxelProvider}.
@@ -70,6 +71,12 @@ function VoxelPrimitive(options) {
    */
   this._traversal = undefined;
 
+  /**
+   * @type {Cesium3DTilesetStatistics}
+   * @private
+   */
+  this._statistics = new Cesium3DTilesetStatistics();
+
   /**
    * This member is not created until the provider is ready.
    *
@@ -450,6 +457,123 @@ function VoxelPrimitive(options) {
     }
   }
 
+  /**
+   * The event fired to indicate that a tile's content was loaded.
+   * <p>
+   * This event is fired during the tileset traversal while the frame is being rendered
+   * so that updates to the tile take effect in the same frame.  Do not create or modify
+   * Cesium entities or primitives during the event listener.
+   * </p>
+   *
+   * @type {Event}
+   *
+   * @example
+   * voxelPrimitive.tileLoad.addEventListener(function() {
+   *     console.log('A tile was loaded.');
+   * });
+   */
+  this.tileLoad = new Event();
+
+  /**
+   * This event fires once for each visible tile in a frame.
+   * <p>
+   * This event is fired during the traversal while the frame is being rendered.
+   *
+   * @type {Event}
+   *
+   * @example
+   * voxelPrimitive.tileVisible.addEventListener(function() {
+   *     console.log('A tile is visible.');
+   * });
+   *
+   */
+  this.tileVisible = new Event();
+
+  /**
+   * The event fired to indicate that a tile's content failed to load.
+   *
+   * @type {Event}
+   *
+   * @example
+   * voxelPrimitive.tileFailed.addEventListener(function() {
+   *     console.log('An error occurred loading tile.');
+   * });
+   */
+  this.tileFailed = new Event();
+
+  /**
+   * The event fired to indicate that a tile's content was unloaded.
+   *
+   * @type {Event}
+   *
+   * @example
+   * voxelPrimitive.tileUnload.addEventListener(function() {
+   *     console.log('A tile was unloaded from the cache.');
+   * });
+   *
+   */
+  this.tileUnload = new Event();
+
+  /**
+   * The event fired to indicate progress of loading new tiles. This event is fired when a new tile
+   * is requested, when a requested tile is finished downloading, and when a downloaded tile has been
+   * processed and is ready to render.
+   * <p>
+   * The number of pending tile requests, <code>numberOfPendingRequests</code>, and number of tiles
+   * processing, <code>numberOfTilesProcessing</code> are passed to the event listener.
+   * </p>
+   * <p>
+   * This event is fired at the end of the frame after the scene is rendered.
+   * </p>
+   *
+   * @type {Event}
+   *
+   * @example
+   * voxelPrimitive.loadProgress.addEventListener(function(numberOfPendingRequests, numberOfTilesProcessing) {
+   *     if ((numberOfPendingRequests === 0) && (numberOfTilesProcessing === 0)) {
+   *         console.log('Finished loading');
+   *         return;
+   *     }
+   *
+   *     console.log(`Loading: requests: ${numberOfPendingRequests}, processing: ${numberOfTilesProcessing}`);
+   * });
+   */
+  this.loadProgress = new Event();
+
+  /**
+   * The event fired to indicate that all tiles that meet the screen space error this frame are loaded. The voxel
+   * primitive is completely loaded for this view.
+   * <p>
+   * This event is fired at the end of the frame after the scene is rendered.
+   * </p>
+   *
+   * @type {Event}
+   *
+   * @example
+   * voxelPrimitive.allTilesLoaded.addEventListener(function() {
+   *     console.log('All tiles are loaded');
+   * });
+   */
+  this.allTilesLoaded = new Event();
+
+  /**
+   * The event fired to indicate that all tiles that meet the screen space error this frame are loaded. This event
+   * is fired once when all tiles in the initial view are loaded.
+   * <p>
+   * This event is fired at the end of the frame after the scene is rendered.
+   * </p>
+   *
+   * @type {Event}
+   *
+   * @example
+   * voxelPrimitive.initialTilesLoaded.addEventListener(function() {
+   *     console.log('Initial tiles are loaded');
+   * });
+   *
+   * @see Cesium3DTileset#allTilesLoaded
+   */
+  this.initialTilesLoaded = new Event();
+
   // If the provider fails to initialize the primitive will fail too.
   const provider = this._provider;
   initialize(this, provider);

package/Source/Scene/VoxelProvider.js

@@ -186,6 +186,16 @@ Object.defineProperties(VoxelProvider.prototype, {
     get: DeveloperError.throwInstantiationError,
   },
 
+  /**
+   * The number of levels of detail containing available tiles in the tileset.
+   *
+   * @type {number|undefined}
+   * @readonly
+   */
+  availableLevels: {
+    get: DeveloperError.throwInstantiationError,
+  },
+
   /**
    * Gets the number of keyframes in the dataset.
    * This should not be called before {@link VoxelProvider#ready} returns true.