@cesium/engine 21.0.1 → 22.0.0

package/index.d.ts

@@ -2801,6 +2801,234 @@ export class CatmullRomSpline {
     evaluate(time: number, result?: Cartesian3): Cartesian3;
 }
 
+/**
+ * Terrain data for a single tile where the terrain data is represented as a glb (binary glTF).
+ * @param options - Object with the following properties:
+ * @param options.gltf - The parsed glTF JSON.
+ * @param options.minimumHeight - The minimum terrain height within the tile, in meters above the ellipsoid.
+ * @param options.maximumHeight - The maximum terrain height within the tile, in meters above the ellipsoid.
+ * @param options.boundingSphere - A sphere bounding all of the vertices in the mesh.
+ * @param options.orientedBoundingBox - An oriented bounding box containing all of the vertices in the mesh.
+ * @param options.horizonOcclusionPoint - The horizon occlusion point of the mesh. If this point
+ *                      is below the horizon, the entire tile is assumed to be below the horizon as well.
+ *                      The point is expressed in ellipsoid-scaled coordinates.
+ * @param options.skirtHeight - The height of the skirt to add on the edges of the tile.
+ * @param [options.requestVertexNormals = false] - Indicates whether normals should be loaded.
+ * @param [options.requestWaterMask = false] - Indicates whether water mask data should be loaded.
+ * @param [options.credits] - Array of credits for this tile.
+ * @param [options.childTileMask = 15] - A bit mask indicating which of this tile's four children exist.
+ *                 If a child's bit is set, geometry will be requested for that tile as well when it
+ *                 is needed.  If the bit is cleared, the child tile is not requested and geometry is
+ *                 instead upsampled from the parent.  The bit values are as follows:
+ *                 <table>
+ *                  <tr><th>Bit Position</th><th>Bit Value</th><th>Child Tile</th></tr>
+ *                  <tr><td>0</td><td>1</td><td>Southwest</td></tr>
+ *                  <tr><td>1</td><td>2</td><td>Southeast</td></tr>
+ *                  <tr><td>2</td><td>4</td><td>Northwest</td></tr>
+ *                  <tr><td>3</td><td>8</td><td>Northeast</td></tr>
+ *                 </table>
+ * @param [options.waterMask] - The buffer containing the water mask.
+ */
+export class Cesium3DTilesTerrainData {
+    constructor(options: {
+        gltf: {
+            [key: string]: any;
+        };
+        minimumHeight: number;
+        maximumHeight: number;
+        boundingSphere: BoundingSphere;
+        orientedBoundingBox: OrientedBoundingBox;
+        horizonOcclusionPoint: Cartesian3;
+        skirtHeight: number;
+        requestVertexNormals?: boolean;
+        requestWaterMask?: boolean;
+        credits?: Credit[];
+        childTileMask?: number;
+        waterMask?: Uint8Array;
+    });
+    /**
+     * An array of credits for this tile.
+     */
+    credits: Credit[] | undefined;
+    /**
+     * The water mask included in this terrain data, if any. A water mask is a rectangular
+     * Uint8Array or image where a value of 255 indicates water and a value of 0 indicates land.
+     * Values in between 0 and 255 are allowed as well to smoothly blend between land and water.
+     */
+    waterMask: Uint8Array | HTMLImageElement | HTMLCanvasElement | ImageBitmap | undefined;
+    /**
+     * Returns the terrain height at a specified longitude and latitude, or undefined if the mesh is undefined.
+     * @param rectangle - The rectangle covered by this terrain data.
+     * @param longitude - The longitude in radians.
+     * @param latitude - The latitude in radians.
+     * @returns The terrain height at the specified position, or undefined if the mesh is undefined.
+     *          If the position is outside the rectangle, this method will extrapolate the height,
+     *          which is likely to be wildly incorrect for positions far outside the rectangle.
+     */
+    interpolateHeight(rectangle: Rectangle, longitude: number, latitude: number): number | undefined;
+    /**
+     * Determines if a given child tile is available, based on the
+     * {@link TerrainData#childTileMask}. The given child tile coordinates are assumed
+     * to be one of the four children of this tile. If non-child tile coordinates are
+     * given, the availability of the southeast child tile is returned.
+     * @param thisX - The tile X coordinate of this (the parent) tile.
+     * @param thisY - The tile Y coordinate of this (the parent) tile.
+     * @param childX - The tile X coordinate of the child tile to check for availability.
+     * @param childY - The tile Y coordinate of the child tile to check for availability.
+     * @returns True if the child tile is available; otherwise, false.
+     */
+    isChildAvailable(thisX: number, thisY: number, childX: number, childY: number): boolean;
+    /**
+     * Upsamples this terrain data for use by a descendant tile.
+     * @param tilingScheme - The tiling scheme of this terrain data.
+     * @param thisX - The X coordinate of this tile in the tiling scheme.
+     * @param thisY - The Y coordinate of this tile in the tiling scheme.
+     * @param thisLevel - The level of this tile in the tiling scheme.
+     * @param descendantX - The X coordinate within the tiling scheme of the descendant tile for which we are upsampling.
+     * @param descendantY - The Y coordinate within the tiling scheme of the descendant tile for which we are upsampling.
+     * @param descendantLevel - The level within the tiling scheme of the descendant tile for which we are upsampling.
+     * @returns A promise for upsampled terrain data for the descendant tile, or undefined if createMesh has not been called yet or too many asynchronous upsample operations are in progress and the request has been deferred.
+     */
+    upsample(tilingScheme: TilingScheme, thisX: number, thisY: number, thisLevel: number, descendantX: number, descendantY: number, descendantLevel: number): Promise<TerrainData> | undefined;
+    /**
+     * Gets a value indicating whether or not this terrain data was created by upsampling lower resolution
+     * terrain data. If this value is false, the data was obtained from some other source, such
+     * as by downloading it from a remote server. This method should return true for instances
+     * returned from a call to {@link Cesium3DTilesTerrainData#upsample}.
+     * @returns True if this instance was created by upsampling; otherwise, false.
+     */
+    wasCreatedByUpsampling(): boolean;
+}
+
+export namespace Cesium3DTilesTerrainProvider {
+    /**
+     * Initialization options for the Cesium3DTilesTerrainProvider constructor
+     * @property [requestVertexNormals = false] - Flag that indicates if the client should request additional lighting information from the server, in the form of per vertex normals if available.
+     * @property [requestWaterMask = false] - Flag that indicates if the client should request per tile water masks from the server, if available.
+     * @property [ellipsoid = Ellipsoid.default] - The ellipsoid.  If not specified, the WGS84 ellipsoid is used.
+     * @property [credit] - A credit for the data source, which is displayed on the canvas.
+     */
+    type ConstructorOptions = {
+        requestVertexNormals?: boolean;
+        requestWaterMask?: boolean;
+        ellipsoid?: Ellipsoid;
+        credit?: Credit | string;
+    };
+}
+
+/**
+ * <div class="notice">
+ * To construct a Cesium3DTilesTerrainProvider, call {@link Cesium3DTilesTerrainProvider.fromIonAssetId} or {@link Cesium3DTilesTerrainProvider.fromUrl}. Do not call the constructor directly.
+ * </div>
+ *
+ * A {@link TerrainProvider} that accesses terrain data in a 3D Tiles format.
+ * @param [options] - An object describing initialization options
+ */
+export class Cesium3DTilesTerrainProvider {
+    constructor(options?: Cesium3DTilesTerrainProvider.ConstructorOptions);
+    /**
+     * Creates a {@link TerrainProvider} that accesses terrain data in a Cesium 3D Tiles format.
+     * @example
+     * // Create terrain with normals.
+     * try {
+     *   const viewer = new Cesium.Viewer("cesiumContainer", {
+     *     terrainProvider: await Cesium.Cesium3DTilesTerrainProvider.fromUrl(
+     *       Cesium.IonResource.fromAssetId(3956), {
+     *         requestVertexNormals: true
+     *     })
+     *   });
+     * } catch (error) {
+     *   console.log(error);
+     * }
+     * @param url - The URL of the Cesium terrain server.
+     * @param [options] - An object describing initialization options.
+     * @returns A promise that resolves to the terrain provider.
+     */
+    static fromUrl(url: Resource | string | Promise<Resource> | Promise<string>, options?: Cesium3DTilesTerrainProvider.ConstructorOptions): Promise<Cesium3DTilesTerrainProvider>;
+    /**
+     * Creates a {@link TerrainProvider} from a Cesium ion asset ID that accesses terrain data in a Cesium 3D Tiles format
+     * @example
+     * // Create GTOPO30 with vertex normals
+     * try {
+     *   const viewer = new Cesium.Viewer("cesiumContainer", {
+     *     terrainProvider: await Cesium.Cesium3DTilesTerrainProvider.fromIonAssetId(2732686, {
+     *         requestVertexNormals: true
+     *     })
+     *   });
+     * } catch (error) {
+     *   console.log(error);
+     * }
+     * @param assetId - The Cesium ion asset id.
+     * @param [options] - An object describing initialization options.
+     */
+    static fromIonAssetId(assetId: number, options?: CesiumTerrainProvider.ConstructorOptions): Promise<CesiumTerrainProvider>;
+    /**
+     * Requests the geometry for a given tile. This function should not be called before
+     * {@link Cesium3DTilesTerrainProvider#ready} returns true. The result must include terrain data and
+     * may optionally include a water mask and an indication of which child tiles are available.
+     * @param x - The X coordinate of the tile for which to request geometry.
+     * @param y - The Y coordinate of the tile for which to request geometry.
+     * @param level - The level of the tile for which to request geometry.
+     * @param [request] - The request object. Intended for internal use only.
+     * @returns A promise for the requested geometry. If this method
+     *          returns undefined instead of a promise, it is an indication that too many requests are already
+     *          pending and the request will be retried later.
+     */
+    requestTileGeometry(x: number, y: number, level: number, request?: Request): Promise<Cesium3DTilesTerrainData> | undefined;
+    /**
+     * Determines whether data for a tile is available to be loaded.
+     * @param x - The X coordinate of the tile for which to request geometry.
+     * @param y - The Y coordinate of the tile for which to request geometry.
+     * @param level - The level of the tile for which to request geometry.
+     * @returns Undefined if not supported or availability is unknown, otherwise true or false.
+     */
+    getTileDataAvailable(x: number, y: number, level: number): boolean | undefined;
+    /**
+     * Make sure we load availability data for a tile
+     * @param _x - The X coordinate of the tile for which to request geometry.
+     * @param _y - The Y coordinate of the tile for which to request geometry.
+     * @param _level - The level of the tile for which to request geometry.
+     * @returns Undefined if nothing need to be loaded or a Promise that resolves when all required tiles are loaded
+     */
+    loadTileDataAvailability(_x: number, _y: number, _level: number): Promise<void> | undefined;
+    /**
+     * Get the maximum geometric error allowed in a tile at a given level.
+     * @param level - The tile level for which to get the maximum geometric error.
+     * @returns The maximum geometric error.
+     */
+    getLevelMaximumGeometricError(level: number): number;
+    /**
+     * Gets an event that is raised when the terrain provider encounters an asynchronous error. By subscribing
+     * to the event, you will be notified of the error and can potentially recover from it. Event listeners
+     * are passed an instance of {@link TileProviderError}.
+     */
+    errorEvent: Event;
+    /**
+     * Gets the credit to display when this terrain provider is active. Typically this is used to credit
+     * the source of the terrain.
+     */
+    credit: Credit;
+    /**
+     * Gets the tiling scheme used by the provider.
+     */
+    tilingScheme: TilingScheme;
+    /**
+     * Gets a value indicating whether or not the provider includes a water mask. The water mask
+     * indicates which areas of the globe are water rather than land, so they can be rendered
+     * as a reflective surface with animated waves.
+     */
+    hasWaterMask: boolean;
+    /**
+     * Gets a value indicating whether or not the requested tiles include vertex normals.
+     */
+    hasVertexNormals: boolean;
+    /**
+     * Gets an object that can be used to determine availability of terrain from this provider, such as
+     * at points and in rectangles.
+     */
+    availability: TileAvailability | undefined;
+}
+
 export namespace CesiumTerrainProvider {
     /**
      * Initialization options for the CesiumTerrainProvider constructor
@@ -3602,6 +3830,12 @@ export class Color {
      * @returns The modified result parameter or a new instance if result was undefined.
      */
     toBytes(result?: number[]): number[];
+    /**
+     * Converts RGBA values in bytes to a single numeric unsigned 32-bit RGBA value, using the endianness
+     * of the system.
+     * @returns A single numeric unsigned 32-bit RGBA value.
+     */
+    static bytesToRgba(): number;
     /**
      * Converts this color to a single numeric unsigned 32-bit RGBA value, using the endianness
      * of the system.
@@ -7620,7 +7854,7 @@ export class GoogleEarthEnterpriseTerrainData {
     upsample(tilingScheme: TilingScheme, thisX: number, thisY: number, thisLevel: number, descendantX: number, descendantY: number, descendantLevel: number): Promise<HeightmapTerrainData> | undefined;
     /**
      * Determines if a given child tile is available, based on the
-     * {@link HeightmapTerrainData.childTileMask}.  The given child tile coordinates are assumed
+     * {@link GoogleEarthEnterpriseTerrainData.childTileMask}.  The given child tile coordinates are assumed
      * to be one of the four children of this tile.  If non-child tile coordinates are
      * given, the availability of the southeast child tile is returned.
      * @param thisX - The tile X coordinate of this (the parent) tile.
@@ -8133,7 +8367,7 @@ export class HeightmapTerrainData {
      * Uint8Array or image where a value of 255 indicates water and a value of 0 indicates land.
      * Values in between 0 and 255 are allowed as well to smoothly blend between land and water.
      */
-    waterMask: Uint8Array | HTMLImageElement | HTMLCanvasElement | undefined;
+    waterMask: Uint8Array | HTMLImageElement | HTMLCanvasElement | ImageBitmap | undefined;
     /**
      * Computes the terrain height at a specified longitude and latitude.
      * @param rectangle - The rectangle covered by this terrain data.
@@ -8821,7 +9055,7 @@ export class IonGeocoderService {
  * A {@link Resource} instance that encapsulates Cesium ion asset access.
  * This object is normally not instantiated directly, use {@link IonResource.fromAssetId}.
  * @param endpoint - The result of the Cesium ion asset endpoint service.
- * @param endpointResource - The resource used to retrieve the endpoint.
+ * @param endpointResource - The original resource used to retrieve the endpoint.
  */
 export class IonResource extends Resource {
     constructor(endpoint: any, endpointResource: Resource);
@@ -16462,7 +16696,7 @@ export class TerrainData {
      * Uint8Array or image where a value of 255 indicates water and a value of 0 indicates land.
      * Values in between 0 and 255 are allowed as well to smoothly blend between land and water.
      */
-    waterMask: Uint8Array | HTMLImageElement | HTMLCanvasElement | undefined;
+    waterMask: Uint8Array | HTMLImageElement | HTMLCanvasElement | ImageBitmap | undefined;
     /**
      * Computes the terrain height at a specified longitude and latitude.
      * @param rectangle - The rectangle covered by this terrain data.
@@ -18385,7 +18619,7 @@ export function barycentricCoordinates(point: Cartesian2 | Cartesian3, p0: Carte
  *        of the index before which the itemToFind should be inserted in order to maintain the
  *        sorted order of the array.
  */
-export function binarySearch(array: any[], itemToFind: any, comparator: binarySearchComparator): number;
+export function binarySearch(array: any[] | Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array, itemToFind: any, comparator: binarySearchComparator): number;
 
 /**
  * A function used to compare two items while performing a binary search.
@@ -18649,7 +18883,7 @@ export function isLeapYear(year: number): boolean;
  * @param comparator - The function to use to compare elements in the array.
  * @param [userDefinedObject] - Any item to pass as the third parameter to <code>comparator</code>.
  */
-export function mergeSort(array: any[], comparator: mergeSortComparator, userDefinedObject?: any): void;
+export function mergeSort(array: any[] | Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array, comparator: mergeSortComparator, userDefinedObject?: any): void;
 
 /**
  * A function used to compare two items while performing a merge sort.
@@ -25639,6 +25873,8 @@ export type WebGLOptions = {
     failIfMajorPerformanceCaveat?: boolean;
 };
 
+export function PickId(pickObjects: Map<number, object>, key: number, color: Color): void;
+
 /**
  * The data type of a pixel.
  */
@@ -32872,31 +33108,28 @@ export function removeExtension(gltf: any, extension: string): any;
 export namespace Google2DImageryProvider {
     /**
      * Initialization options for the Google2DImageryProvider constructor
-     * @property options - Object with the following properties:
-     * @property options.key - The Google api key to send with tile requests.
-     * @property options.session - The Google session token that tracks the current state of your map and viewport.
-     * @property options.url - The Google 2D maps endpoint.
-     * @property options.tileWidth - The width of each tile in pixels.
-     * @property options.tileHeight - The height of each tile in pixels.
-     * @property [options.ellipsoid = Ellipsoid.default] - The ellipsoid.  If not specified, the default ellipsoid is used.
-     * @property [options.minimumLevel = 0] - The minimum level-of-detail supported by the imagery provider.  Take care when specifying
+     * @property key - The Google api key to send with tile requests.
+     * @property session - The Google session token that tracks the current state of your map and viewport.
+     * @property url - The Google 2D maps endpoint.
+     * @property tileWidth - The width of each tile in pixels.
+     * @property tileHeight - The height of each tile in pixels.
+     * @property [ellipsoid = Ellipsoid.default] - The ellipsoid.  If not specified, the default ellipsoid is used.
+     * @property [minimumLevel = 0] - The minimum level-of-detail supported by the imagery provider.  Take care when specifying
      *                 this that the number of tiles at the minimum level is small, such as four or less.  A larger number is likely
      *                 to result in rendering problems.
-     * @property [options.maximumLevel = 22] - The maximum level-of-detail supported by the imagery provider.
-     * @property [options.rectangle = Rectangle.MAX_VALUE] - The rectangle, in radians, covered by the image.
+     * @property [maximumLevel = 22] - The maximum level-of-detail supported by the imagery provider.
+     * @property [rectangle = Rectangle.MAX_VALUE] - The rectangle, in radians, covered by the image.
      */
     type ConstructorOptions = {
-        options: {
-            key: string;
-            session: string;
-            url: string | Resource | IonResource;
-            tileWidth: string;
-            tileHeight: string;
-            ellipsoid?: Ellipsoid;
-            minimumLevel?: number;
-            maximumLevel?: number;
-            rectangle?: Rectangle;
-        };
+        key: string;
+        session: string;
+        url: string | Resource | IonResource;
+        tileWidth: string;
+        tileHeight: string;
+        ellipsoid?: Ellipsoid;
+        minimumLevel?: number;
+        maximumLevel?: number;
+        rectangle?: Rectangle;
     };
 }
 
@@ -39737,6 +39970,21 @@ export type PickedMetadataInfo = {
     classProperty: MetadataClassProperty;
 };
 
+/**
+ * @param pickedResults - the results from the pickCallback
+ * @param limit - If supplied, stop drilling after collecting this many picks.
+ * @returns whether picking should end
+ */
+export function addDrillPickedResults(pickedResults: object[], limit: number, results: object[], pickedPrimitives: object[], pickedAttributes: object[], pickedFeatures: object[]): boolean;
+
+/**
+ * Drill pick by repeatedly calling a given `pickCallback`, each time stripping away the previously picked objects.
+ * @param pickCallback - Pick callback to execute each iteration
+ * @param [limit = Number.MAX_VALUE] - If supplied, stop drilling after collecting this many picks
+ * @returns List of picked results
+ */
+export function drillPick(pickCallback: (...params: any[]) => any, limit?: number): object[];
+
 /**
  * Remove all invalid binary body references from the batch table
  * JSON of the given parsed content.
@@ -41877,6 +42125,12 @@ export class Scene {
      * The light source for shading. Defaults to a directional light from the Sun.
      */
     light: Light;
+    /**
+     * Whether or not to enable edge visibility rendering for 3D tiles.
+     * When enabled, creates a framebuffer with multiple render targets
+     * for advanced edge detection and visibility techniques.
+     */
+    _enableEdgeVisibility: boolean;
     /**
      * Use this to set the default value for {@link Scene#logarithmicDepthBuffer} in newly constructed Scenes
      * This property relies on fragmentDepth being supported.