@cesium/engine 9.0.0 → 9.2.0

package/index.d.ts

@@ -6425,7 +6425,7 @@ export class Event<Listener extends (...args: any[]) => void = (...args: any[])
      * Raises the event by calling each registered listener with all supplied arguments.
      * @param arguments - This method takes any number of parameters and passes them through to the listener functions.
      */
-    raiseEvent(...arguments: Parameters<Listener>[]): void;
+    raiseEvent(...arguments: Parameters<Listener>): void;
 }
 
 export namespace Event {
@@ -14210,6 +14210,14 @@ export class Rectangle {
      * @returns The modified result parameter or a new Rectangle instance if none was provided.
      */
     static fromCartesianArray(cartesians: Cartesian3[], ellipsoid?: Ellipsoid, result?: Rectangle): Rectangle;
+    /**
+     * Create a rectangle from a bounding sphere, ignoring height.
+     * @param boundingSphere - The bounding sphere.
+     * @param [ellipsoid = Ellipsoid.WGS84] - The ellipsoid.
+     * @param [result] - The object onto which to store the result, or undefined if a new instance should be created.
+     * @returns The modified result parameter or a new Rectangle instance if none was provided.
+     */
+    static fromBoundingSphere(boundingSphere: BoundingSphere, ellipsoid?: Ellipsoid, result?: Rectangle): Rectangle;
     /**
      * Duplicates a Rectangle.
      * @param rectangle - The rectangle to clone.
@@ -18524,7 +18532,7 @@ export function queryToObject(queryString: string): any;
  * @param terrainProvider - The terrain provider from which to query heights.
  * @param level - The terrain level-of-detail from which to query terrain heights.
  * @param positions - The positions to update with terrain heights.
- * @param [rejectOnTileFail = false] - If true, for a failed terrain tile request the promise will be rejected. If false, returned heights will be undefined.
+ * @param [rejectOnTileFail = false] - If true, for any failed terrain tile requests, the promise will be rejected. If false, returned heights will be undefined.
  * @returns A promise that resolves to the provided list of positions when terrain the query has completed.
  */
 export function sampleTerrain(terrainProvider: TerrainProvider, level: number, positions: Cartographic[], rejectOnTileFail?: boolean): Promise<Cartographic[]>;
@@ -25842,7 +25850,7 @@ export namespace Billboard {
      */
     type ConstructorOptions = {
         position: Cartesian3;
-        id?: string;
+        id?: any;
         show?: boolean;
         image?: string | HTMLCanvasElement;
         scale?: number;
@@ -28949,6 +28957,7 @@ export namespace Cesium3DTileset {
      * @property [immediatelyLoadDesiredLevelOfDetail = false] - When <code>skipLevelOfDetail</code> is <code>true</code>, only tiles that meet the maximum screen space error will ever be downloaded. Skipping factors are ignored and just the desired tiles are loaded.
      * @property [loadSiblings = false] - When <code>skipLevelOfDetail</code> is <code>true</code>, determines whether siblings of visible tiles are always downloaded during traversal.
      * @property [clippingPlanes] - The {@link ClippingPlaneCollection} used to selectively disable rendering the tileset.
+     * @property [clippingPolygons] - The {@link ClippingPolygonCollection} used to selectively disable rendering the tileset.
      * @property [classificationType] - Determines whether terrain, 3D Tiles or both will be classified by this tileset. See {@link Cesium3DTileset#classificationType} for details about restrictions and limitations.
      * @property [ellipsoid = Ellipsoid.WGS84] - The ellipsoid determining the size and shape of the globe.
      * @property [pointCloudShading] - Options for constructing a {@link PointCloudShading} object to control point attenuation based on geometric error and lighting.
@@ -29012,6 +29021,7 @@ export namespace Cesium3DTileset {
         immediatelyLoadDesiredLevelOfDetail?: boolean;
         loadSiblings?: boolean;
         clippingPlanes?: ClippingPlaneCollection;
+        clippingPolygons?: ClippingPolygonCollection;
         classificationType?: ClassificationType;
         ellipsoid?: Ellipsoid;
         pointCloudShading?: any;
@@ -29531,6 +29541,10 @@ export class Cesium3DTileset {
      * The {@link ClippingPlaneCollection} used to selectively disable rendering the tileset.
      */
     clippingPlanes: ClippingPlaneCollection;
+    /**
+     * The {@link ClippingPolygonCollection} used to selectively disable rendering the tileset.
+     */
+    clippingPolygons: ClippingPolygonCollection;
     /**
      * Gets the tileset's properties dictionary object, which contains metadata about per-feature properties.
      * <p>
@@ -30286,6 +30300,200 @@ export class ClippingPlaneCollection {
     destroy(): void;
 }
 
+/**
+ * A geodesic polygon to be used with {@link ClippingPlaneCollection} for selectively hiding regions in a model, a 3D tileset, or the globe.
+ * @example
+ * const positions = Cesium.Cartesian3.fromRadiansArray([
+ *     -1.3194369277314022,
+ *     0.6988062530900625,
+ *     -1.31941,
+ *     0.69879,
+ *     -1.3193955980204217,
+ *     0.6988091578771254,
+ *     -1.3193931220959367,
+ *     0.698743632490865,
+ *     -1.3194358224045408,
+ *     0.6987471965556998,
+ * ]);
+ *
+ * const polygon = new Cesium.ClippingPolygon({
+ *     positions: positions
+ * });
+ * @param options - Object with the following properties:
+ * @param options.positions - A list of three or more Cartesian coordinates defining the outer ring of the clipping polygon.
+ */
+export class ClippingPolygon {
+    constructor(options: {
+        positions: Cartesian3[];
+        ellipsoid?: Ellipsoid;
+    });
+    /**
+     * Returns the total number of positions in the polygon, include any holes.
+     */
+    readonly length: number;
+    /**
+     * Returns the outer ring of positions.
+     */
+    readonly positions: Cartesian3[];
+    /**
+     * Returns the ellipsoid used to project the polygon onto surfaces when clipping.
+     */
+    readonly ellipsoid: Ellipsoid;
+    /**
+     * Clones the ClippingPolygon without setting its ownership.
+     * @param polygon - The ClippingPolygon to be cloned
+     * @param [result] - The object on which to store the cloned parameters.
+     * @returns a clone of the input ClippingPolygon
+     */
+    static clone(polygon: ClippingPolygon, result?: ClippingPolygon): ClippingPolygon;
+    /**
+     * Compares the provided ClippingPolygons and returns
+     * <code>true</code> if they are equal, <code>false</code> otherwise.
+     * @param left - The first polygon.
+     * @param right - The second polygon.
+     * @returns <code>true</code> if left and right are equal, <code>false</code> otherwise.
+     */
+    static equals(left: Plane, right: Plane): boolean;
+    /**
+     * Computes a cartographic rectangle which encloses the polygon defined by the list of positions, including cases over the international date line and the poles.
+     * @param [result] - An object in which to store the result.
+     * @returns The result rectangle
+     */
+    computeRectangle(result?: Rectangle): Rectangle;
+}
+
+/**
+ * Specifies a set of clipping polygons. Clipping polygons selectively disable rendering in a region
+ * inside or outside the specified list of {@link ClippingPolygon} objects for a single glTF model, 3D Tileset, or the globe.
+ *
+ * Clipping Polygons are only supported in WebGL 2 contexts.
+ * @example
+ * const positions = Cesium.Cartesian3.fromRadiansArray([
+ *     -1.3194369277314022,
+ *     0.6988062530900625,
+ *     -1.31941,
+ *     0.69879,
+ *     -1.3193955980204217,
+ *     0.6988091578771254,
+ *     -1.3193931220959367,
+ *     0.698743632490865,
+ *     -1.3194358224045408,
+ *     0.6987471965556998,
+ * ]);
+ *
+ * const polygon = new Cesium.ClippingPolygon({
+ *     positions: positions
+ * });
+ *
+ * const polygons = new Cesium.ClippingPolygonCollection({
+ *    polygons: [ polygon ]
+ * });
+ * @param [options] - Object with the following properties:
+ * @param [options.polygons = []] - An array of {@link ClippingPolygon} objects used to selectively disable rendering on the inside of each polygon.
+ * @param [options.enabled = true] - Determines whether the clipping polygons are active.
+ * @param [options.inverse = false] - If true, a region will be clipped if it is outside of every polygon in the collection. Otherwise, a region will only be clipped if it is on the inside of any polygon.
+ */
+export class ClippingPolygonCollection {
+    constructor(options?: {
+        polygons?: ClippingPolygon[];
+        enabled?: boolean;
+        inverse?: boolean;
+    });
+    /**
+     * An event triggered when a new clipping polygon is added to the collection.  Event handlers
+     * are passed the new polygon and the index at which it was added.
+     */
+    polygonAdded: Event;
+    /**
+     * An event triggered when a new clipping polygon is removed from the collection.  Event handlers
+     * are passed the new polygon and the index from which it was removed.
+     */
+    polygonRemoved: Event;
+    /**
+     * Returns the number of polygons in this collection.  This is commonly used with
+     * {@link ClippingPolygonCollection#get} to iterate over all the polygons
+     * in the collection.
+     */
+    readonly length: number;
+    /**
+     * Adds the specified {@link ClippingPolygon} to the collection to be used to selectively disable rendering
+     * on the inside of each polygon. Use {@link ClippingPolygonCollection#unionClippingRegions} to modify
+     * how modify the clipping behavior of multiple polygons.
+     * @example
+     * const polygons = new Cesium.ClippingPolygonCollection();
+     *
+     * const positions = Cesium.Cartesian3.fromRadiansArray([
+     *     -1.3194369277314022,
+     *     0.6988062530900625,
+     *     -1.31941,
+     *     0.69879,
+     *     -1.3193955980204217,
+     *     0.6988091578771254,
+     *     -1.3193931220959367,
+     *     0.698743632490865,
+     *     -1.3194358224045408,
+     *     0.6987471965556998,
+     * ]);
+     *
+     * polygons.add(new Cesium.ClippingPolygon({
+     *     positions: positions
+     * }));
+     * @param polygon - The ClippingPolygon to add to the collection.
+     * @returns The added ClippingPolygon.
+     */
+    add(polygon: ClippingPolygon): ClippingPolygon;
+    /**
+     * Returns the clipping polygon in the collection at the specified index.  Indices are zero-based
+     * and increase as polygons are added.  Removing a polygon polygon all polygons after
+     * it to the left, changing their indices.  This function is commonly used with
+     * {@link ClippingPolygonCollection#length} to iterate over all the polygons
+     * in the collection.
+     * @param index - The zero-based index of the polygon.
+     * @returns The ClippingPolygon at the specified index.
+     */
+    get(index: number): ClippingPolygon;
+    /**
+     * Checks whether this collection contains a ClippingPolygon equal to the given ClippingPolygon.
+     * @param polygon - The ClippingPolygon to check for.
+     * @returns true if this collection contains the ClippingPolygon, false otherwise.
+     */
+    contains(polygon: ClippingPolygon): boolean;
+    /**
+     * Removes the first occurrence of the given ClippingPolygon from the collection.
+     * @returns <code>true</code> if the polygon was removed; <code>false</code> if the polygon was not found in the collection.
+     */
+    remove(polygon: ClippingPolygon): boolean;
+    /**
+     * Removes all polygons from the collection.
+     */
+    removeAll(): void;
+    /**
+     * Function for checking if the context will allow clipping polygons, which require floating point textures.
+     * @param scene - The scene that will contain clipped objects and clipping textures.
+     * @returns <code>true</code> if the context supports clipping polygons.
+     */
+    static isSupported(scene: Scene | any): boolean;
+    /**
+     * Returns true if this object was destroyed; otherwise, false.
+     * <br /><br />
+     * If this object was destroyed, it should not be used; calling any function other than
+     * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
+     * @returns <code>true</code> if this object was destroyed; otherwise, <code>false</code>.
+     */
+    isDestroyed(): boolean;
+    /**
+     * Destroys the WebGL resources held by this object.  Destroying an object allows for deterministic
+     * release of WebGL resources, instead of relying on the garbage collector to destroy this object.
+     * <br /><br />
+     * Once an object is destroyed, it should not be used; calling any function other than
+     * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.  Therefore,
+     * assign the return value (<code>undefined</code>) to the object as done in the example.
+     * @example
+     * clippingPolygons = clippingPolygons && clippingPolygons.destroy();
+     */
+    destroy(): void;
+}
+
 /**
  * A renderable collection of clouds in the 3D scene.
  * <br /><br />
@@ -31695,6 +31903,10 @@ export class Globe {
      * A property specifying a {@link ClippingPlaneCollection} used to selectively disable rendering on the outside of each plane.
      */
     clippingPlanes: ClippingPlaneCollection;
+    /**
+     * A property specifying a {@link ClippingPolygonCollection} used to selectively disable rendering inside or outside a list of polygons.
+     */
+    clippingPolygons: ClippingPolygonCollection;
     /**
      * A property specifying a {@link Rectangle} used to limit globe rendering to a cartographic area.
      * Defaults to the maximum extent of cartographic coordinates.
@@ -34210,7 +34422,7 @@ export namespace Label {
      */
     type ConstructorOptions = {
         position: Cartesian3;
-        id?: string;
+        id?: any;
         show?: boolean;
         text?: string;
         font?: string;
@@ -36411,6 +36623,10 @@ export class Model {
      * The {@link ClippingPlaneCollection} used to selectively disable rendering the model.
      */
     clippingPlanes: ClippingPlaneCollection;
+    /**
+     * The {@link ClippingPolygonCollection} used to selectively disable rendering the model.
+     */
+    clippingPolygons: ClippingPolygonCollection;
     /**
      * The light color when shading the model. When <code>undefined</code> the scene's light color is used instead.
      * <p>
@@ -36648,6 +36864,7 @@ export class Model {
      * @param [options.showOutline = true] - Whether to display the outline for models using the {@link https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/CESIUM_primitive_outline|CESIUM_primitive_outline} extension. When true, outlines are displayed. When false, outlines are not displayed.
      * @param [options.outlineColor = Color.BLACK] - The color to use when rendering outlines.
      * @param [options.clippingPlanes] - The {@link ClippingPlaneCollection} used to selectively disable rendering the model.
+     * @param [options.clippingPolygons] - The {@link ClippingPolygonCollection} used to selectively disable rendering the model.
      * @param [options.lightColor] - The light color when shading the model. When <code>undefined</code> the scene's light color is used instead.
      * @param [options.imageBasedLighting] - The properties for managing image-based lighting on this model.
      * @param [options.backFaceCulling = true] - Whether to cull back-facing geometry. When true, back face culling is determined by the material's doubleSided property; when false, back face culling is disabled. Back faces are not culled if the model's color is translucent.
@@ -36699,6 +36916,7 @@ export class Model {
         showOutline?: boolean;
         outlineColor?: Color;
         clippingPlanes?: ClippingPlaneCollection;
+        clippingPolygons?: ClippingPolygonCollection;
         lightColor?: Cartesian3;
         imageBasedLighting?: ImageBasedLighting;
         backFaceCulling?: boolean;
@@ -41285,6 +41503,14 @@ export class Terrain {
      * are passed the created instance of {@link TerrainProvider}.
      */
     readonly readyEvent: Event<Terrain.ReadyEventCallback>;
+    /**
+     * Returns true when the terrain provider has been successfully created. Otherwise, returns false.
+     */
+    readonly ready: boolean;
+    /**
+     * The terrain provider providing surface geometry to a globe. Do not use until {@link Terrain.readyEvent} is raised.
+     */
+    readonly provider: TerrainProvider;
     /**
      * Creates a {@link Terrain} instance for {@link https://cesium.com/content/#cesium-world-terrain|Cesium World Terrain}.
      * @example