mars3d-cesium 1.129.0 → 1.130.1

package/Build/Cesium/Cesium.d.ts

@@ -13081,6 +13081,13 @@ export enum PixelFormat {
      * A pixel format containing red, green, blue, and alpha channels.
      */
     RGBA = WebGLConstants.RGBA,
+    /**
+     * Integral versions of above types. Required if using integral textures.
+     */
+    RED_INTEGER = WebGLConstants.RED_INTEGER,
+    RG_INTEGER = WebGLConstants.RG_INTEGER,
+    RGB_INTEGER = WebGLConstants.RGB_INTEGER,
+    RGBA_INTEGER = WebGLConstants.RGBA_INTEGER,
     /**
      * A pixel format containing a luminance (intensity) channel.
      */
@@ -28518,6 +28525,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.
@@ -28583,6 +28591,7 @@ export namespace Cesium3DTileset {
         enableCollision?: boolean;
         projectTo2D?: boolean;
         enablePick?: boolean;
+        asynchronouslyLoadImagery?: boolean;
         debugHeatmapTilePropertyName?: string;
         debugFreezeFrame?: boolean;
         debugColorizeTiles?: boolean;
@@ -28975,6 +28984,11 @@ export class Cesium3DTileset {
     When true, outlines are displayed. When false, outlines are not displayed.
      */
     showOutline: boolean;
+    /**
+     * Whether to display Gaussing Splatting (will fall back to point cloud rendering if false)
+    <insert link to spec here>
+     */
+    showGaussianSplatting: boolean;
     /**
      * The color to use when rendering outlines.
      */
@@ -29088,6 +29102,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>
@@ -31847,9 +31875,9 @@ export enum DepthFunction {
 
 /**
  * Returns the type that the given class property has in a GLSL shader.
- *
- * It returns the same string as `PropertyTextureProperty.prototype.getGlslType`
- * for a property texture property with the given class property
+
+It returns the same string as `PropertyTextureProperty.prototype.getGlslType`
+for a property texture property with the given class property
  * @param classProperty - The class property
  * @returns The GLSL shader type string for the property
  */
@@ -31857,8 +31885,8 @@ export function getGlslType(classProperty: MetadataClassProperty): string;
 
 /**
  * Returns a shader statement that applies the inverse of the
- * value transform to the given value, based on the given offset
- * and scale.
+value transform to the given value, based on the given offset
+and scale.
  * @param input - The input value
  * @param offset - The offset
  * @param scale - The scale
@@ -31868,7 +31896,7 @@ export function unapplyValueTransform(input: string, offset: string, scale: stri
 
 /**
  * Returns a shader statement that applies the inverse of the
- * normalization, based on the given component type
+normalization, based on the given component type
  * @param input - The input value
  * @param componentType - The component type
  * @returns The statement
@@ -31877,20 +31905,20 @@ export function unnormalize(input: string, componentType: string): string;
 
 /**
  * Creates a shader statement that returns the value of the specified
- * property, normalized to the range [0, 1].
+property, normalized to the range [0, 1].
  * @param classProperty - The class property
  * @param metadataProperty - The metadata property, either
- * a `PropertyTextureProperty` or a `PropertyAttributeProperty`
+a `PropertyTextureProperty` or a `PropertyAttributeProperty`
  * @returns The string
  */
 export function getSourceValueStringScalar(classProperty: MetadataClassProperty, metadataProperty: any): string;
 
 /**
  * Creates a shader statement that returns the value of the specified
- * component of the given property, normalized to the range [0, 1].
+component of the given property, normalized to the range [0, 1].
  * @param classProperty - The class property
  * @param metadataProperty - The metadata property, either
- * a `PropertyTextureProperty` or a `PropertyAttributeProperty`
+a `PropertyTextureProperty` or a `PropertyAttributeProperty`
  * @param componentName - The name, in ["x", "y", "z", "w"]
  * @returns The string
  */
@@ -34450,7 +34478,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({
@@ -34466,6 +34494,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
  */
@@ -34715,7 +34755,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();
@@ -37669,6 +37709,10 @@ export class Model {
     When true, outlines are displayed. When false, outlines are not displayed.
      */
     showOutline: boolean;
+    /**
+     * Whether to display Gaussian Splatting (will fall back to point cloud rendering if false)
+     */
+    showGaussianSplatting: boolean;
     /**
      * The color to use when rendering outlines.
      */
@@ -37714,6 +37758,10 @@ export class Model {
     {@link Cesium3DTileset}.
      */
     pointCloudShading: PointCloudShading;
+    /**
+     * {@link Cesium3DTileset}.
+     */
+    enableShowGaussianSplatting: PointCloudShading;
     /**
      * The model's custom shader, if it exists. Using custom shaders with a {@link Cesium3DTileStyle}
     may lead to undefined behavior.
@@ -38622,6 +38670,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}
@@ -41215,6 +41283,12 @@ export class PrimitiveCollection {
     destroy(): void;
 }
 
+/**
+ * Do our dequantizing here. When using meshopt, our positions are quantized,
+as well as our quaternions. decodeFilterQuat returns quantized shorts
+ */
+export function dequantizeSplatMeshopt(): void;
+
 /**
  * A simple Least Recently Used (LRU) cache implementation.
  */