mars3d-cesium 1.128.0 → 1.130.0

package/Build/Cesium/Cesium.d.ts

@@ -3087,7 +3087,10 @@ export const Check: {
      * @param {*} test The value to test
      * @exception {DeveloperError} test must be typeof 'object'
      */
-    object(name: string, test: any): asserts test is object;
+    object(
+      name: string,
+      test: any,
+    ): asserts test is Record<string | number | symbol, any>;
     /**
      * Throws if test is not typeof 'boolean'
      *
@@ -13492,8 +13495,9 @@ export class PolygonGeometry {
      * @param array - The packed array.
      * @param [startingIndex = 0] - The starting index of the element to be unpacked.
      * @param [result] - The object into which to store the result.
+     * @returns The modified result parameter or a new PolygonGeometry instance if one was not provided.
      */
-    static unpack(array: number[], startingIndex?: number, result?: PolygonGeometry): void;
+    static unpack(array: number[], startingIndex?: number, result?: PolygonGeometry): PolygonGeometry;
     /**
      * Computes a rectangle which encloses the polygon defined by the list of positions, including cases over the international date line and the poles.
      * @param positions - A linear ring defining the outer boundary of the polygon.
@@ -15002,7 +15006,7 @@ export class RectangleOutlineGeometry {
      * @param array - The packed array.
      * @param [startingIndex = 0] - The starting index of the element to be unpacked.
      * @param [result] - The object into which to store the result.
-     * @returns The modified result parameter or a new Quaternion instance if one was not provided.
+     * @returns The modified result parameter or a new RectangleOutlineGeometry instance if one was not provided.
      */
     static unpack(array: number[], startingIndex?: number, result?: RectangleOutlineGeometry): RectangleOutlineGeometry;
     /**
@@ -28514,6 +28518,7 @@ export namespace Cesium3DTileset {
      * @property [enableCollision = false] - When <code>true</code>, enables collisions for camera or CPU picking. While this is <code>true</code> the camera will be prevented from going below the tileset surface if {@link ScreenSpaceCameraController#enableCollisionDetection} is true.
      * @property [projectTo2D = false] - Whether to accurately project the tileset to 2D. If this is true, the tileset will be projected accurately to 2D, but it will use more memory to do so. If this is false, the tileset will use less memory and will still render in 2D / CV mode, but its projected positions may be inaccurate. This cannot be set after the tileset has been created.
      * @property [enablePick = false] - Whether to allow collision and CPU picking with <code>pick</code> when using WebGL 1. If using WebGL 2 or above, this option will be ignored. If using WebGL 1 and this is true, the <code>pick</code> operation will work correctly, but it will use more memory to do so. If running with WebGL 1 and this is false, the model will use less memory, but <code>pick</code> will always return <code>undefined</code>. This cannot be set after the tileset has loaded.
+     * @property [asynchronouslyLoadImagery = false] - Whether loading imagery that is draped over the tileset should be done asynchronously. If this is <code>true</code>, then tile content will be displayed with its original texture until the imagery texture is loaded. If this is <code>false</code>, then the tile content will not be displayed until the imagery is ready.
      * @property [debugHeatmapTilePropertyName] - The tile variable to colorize as a heatmap. All rendered tiles will be colorized relative to each other's specified variable value.
      * @property [debugFreezeFrame = false] - For debugging only. Determines if only the tiles from last frame should be used for rendering.
      * @property [debugColorizeTiles = false] - For debugging only. When true, assigns a random color to each tile.
@@ -28579,6 +28584,7 @@ export namespace Cesium3DTileset {
         enableCollision?: boolean;
         projectTo2D?: boolean;
         enablePick?: boolean;
+        asynchronouslyLoadImagery?: boolean;
         debugHeatmapTilePropertyName?: string;
         debugFreezeFrame?: boolean;
         debugColorizeTiles?: boolean;
@@ -29084,6 +29090,20 @@ export class Cesium3DTileset {
      * The {@link ClippingPolygonCollection} used to selectively disable rendering the tileset.
      */
     clippingPolygons: ClippingPolygonCollection;
+    /**
+     * The collection of <code>ImageryLayer</code> objects providing 2D georeferenced
+    image data that will be rendered over the tileset.
+    
+    The imagery will be draped over glTF, B3DM, PNTS, or GeoJSON tile content.
+     * @example
+     * // Drape Bing Maps Aerial imagery over the tileset
+    const imageryProvider = await Cesium.createWorldImageryAsync({
+      style: Cesium.IonWorldImageryStyle.AERIAL,
+    });
+    const imageryLayer = new ImageryLayer(imageryProvider);
+    tileset.imageryLayers.add(imageryLayer);
+     */
+    readonly imageryLayers: ImageryLayerCollection;
     /**
      * Gets the tileset's properties dictionary object, which contains metadata about per-feature properties.
     <p>
@@ -34377,7 +34397,7 @@ export namespace ImageryLayer {
                              <code>function(frameState, layer, x, y, level)</code>.  The function is passed the
                              current frame state, this layer, and the x, y, and level coordinates
                              of the imagery tile for which the hue is required, and it is expected to return
-                             the contrast value to use for the tile.  The function is executed for every
+                             the hue value to use for the tile.  The function is executed for every
                              frame and for every tile, so it must be fast.
      * @property [saturation = 1.0] - The saturation of this layer.  1.0 uses the unmodified imagery color.
                              Less than 1.0 reduces the saturation while greater than 1.0 increases it.
@@ -34385,7 +34405,7 @@ export namespace ImageryLayer {
                              <code>function(frameState, layer, x, y, level)</code>.  The function is passed the
                              current frame state, this layer, and the x, y, and level coordinates
                              of the imagery tile for which the saturation is required, and it is expected to return
-                             the contrast value to use for the tile.  The function is executed for every
+                             the saturation value to use for the tile.  The function is executed for every
                              frame and for every tile, so it must be fast.
      * @property [gamma = 1.0] - The gamma correction to apply to this layer.  1.0 uses the unmodified imagery color.
                              This can either be a simple number or a function with the signature
@@ -34446,7 +34466,7 @@ export namespace ImageryLayer {
 
 /**
  * An imagery layer that displays tiled image data from a single imagery provider
-on a {@link Globe}.
+on a {@link Globe} or {@link Cesium3DTileset}.
  * @example
  * // Add an OpenStreetMaps layer
 const imageryLayer = new Cesium.ImageryLayer(new Cesium.OpenStreetMapImageryProvider({
@@ -34462,6 +34482,18 @@ scene.imageryLayers.add(imageryLayer);
 const imageryLayer = Cesium.ImageryLayer.fromProviderAsync(Cesium.IonImageryProvider.fromAssetId(3812));
 imageryLayer.alpha = 0.5;
 scene.imageryLayers.add(imageryLayer);
+ * @example
+ * // Drape Bing Maps Aerial imagery over a 3D tileset
+const tileset = await Cesium.Cesium3DTileset.fromUrl(
+  "http://localhost:8002/tilesets/Seattle/tileset.json"
+);
+scene.primitives.add(tileset);
+
+const imageryProvider = await Cesium.createWorldImageryAsync({
+  style: Cesium.IonWorldImageryStyle.AERIAL,
+});
+const imageryLayer = new ImageryLayer(imageryProvider);
+tileset.imageryLayers.add(imageryLayer);
  * @param [imageryProvider] - The imagery provider to use.
  * @param [options] - An object describing initialization options
  */
@@ -34711,7 +34743,7 @@ export class ImageryLayer {
 }
 
 /**
- * An ordered collection of imagery layers.
+ * An ordered collection of imagery layers for rendering raster imagery on a {@link Globe} or {@link Cesium3DTileset}.
  */
 export class ImageryLayerCollection {
     constructor();
@@ -38618,6 +38650,26 @@ export class ModelNode {
     originalMatrix: Matrix4;
 }
 
+/**
+ * Reads and returns a value with the given type
+at the given byte offset from the data view, in little-endian
+order
+ * @param dataView - Typed data view into a binary buffer
+ * @param byteOffset - The offset, in bytes, from the start of the view to read the data from
+ * @param numberOfComponents - The number of components to read
+ * @param result - The array in which to read the result
+ */
+export type ComponentsReaderCallback = (dataView: DataView, byteOffset: number, numberOfComponents: number, result: number[]) => void;
+
+/**
+ * Reads and returns a value with the given type
+at the given byte offset from the data view, in little-endian
+order
+ * @param dataView - Typed data view into a binary buffer
+ * @param byteOffset - The offset, in bytes, from the start of the view to read the data from
+ */
+export type ComponentReaderCallback = (dataView: DataView, byteOffset: number) => number | bigint;
+
 /**
  * A simple struct that serves as a value of a <code>sampler2D</code>-valued
 uniform. This is used with {@link CustomShader} and {@link TextureManager}