@cesium/engine 17.0.0 → 18.0.1-splats.0

package/Source/Scene/GltfVertexBufferLoader.js

@@ -9,6 +9,7 @@ import JobType from "./JobType.js";
 import ModelComponents from "./ModelComponents.js";
 import ResourceLoader from "./ResourceLoader.js";
 import ResourceLoaderState from "./ResourceLoaderState.js";
+import CesiumMath from "../Core/Math.js";
 
 /**
  * Loads a vertex buffer from a glTF buffer view.
@@ -53,6 +54,7 @@ function GltfVertexBufferLoader(options) {
   const attributeSemantic = options.attributeSemantic;
   const accessorId = options.accessorId;
   const cacheKey = options.cacheKey;
+  const spz = options.spz;
   const asynchronous = options.asynchronous ?? true;
   const loadBuffer = options.loadBuffer ?? false;
   const loadTypedArray = options.loadTypedArray ?? false;
@@ -73,10 +75,10 @@ function GltfVertexBufferLoader(options) {
   const hasDraco = hasDracoCompression(draco, attributeSemantic);
   const hasAttributeSemantic = defined(attributeSemantic);
   const hasAccessorId = defined(accessorId);
-
-  if (hasBufferViewId === hasDraco) {
+  const hasSpz = defined(spz);
+  if (hasBufferViewId === (hasDraco !== hasSpz)) {
     throw new DeveloperError(
-      "One of options.bufferViewId and options.draco must be defined.",
+      "One of options.bufferViewId, options.draco, or options.spz must be defined.",
     );
   }
 
@@ -104,6 +106,7 @@ function GltfVertexBufferLoader(options) {
     Check.typeOf.string("options.attributeSemantic", attributeSemantic);
     Check.typeOf.number("options.accessorId", accessorId);
   }
+
   //>>includeEnd('debug');
 
   this._resourceCache = resourceCache;
@@ -113,6 +116,7 @@ function GltfVertexBufferLoader(options) {
   this._bufferViewId = bufferViewId;
   this._primitive = primitive;
   this._draco = draco;
+  this._spz = spz;
   this._attributeSemantic = attributeSemantic;
   this._accessorId = accessorId;
   this._cacheKey = cacheKey;
@@ -210,6 +214,11 @@ GltfVertexBufferLoader.prototype.load = async function () {
     return this._promise;
   }
 
+  if (defined(this._spz)) {
+    this._promise = loadFromSpz(this);
+    return this._promise;
+  }
+
   if (hasDracoCompression(this._draco, this._attributeSemantic)) {
     this._promise = loadFromDraco(this);
     return this._promise;
@@ -270,6 +279,74 @@ function getQuantizationInformation(
   return quantization;
 }
 
+async function loadFromSpz(vertexBufferLoader) {
+  vertexBufferLoader._state = ResourceLoaderState.LOADING;
+  const resourceCache = vertexBufferLoader._resourceCache;
+  try {
+    const spzLoader = resourceCache.getSpzLoader({
+      gltf: vertexBufferLoader._gltf,
+      primitive: vertexBufferLoader._primitive,
+      spz: vertexBufferLoader._spz,
+      gltfResource: vertexBufferLoader._gltfResource,
+      baseResource: vertexBufferLoader._baseResource,
+    });
+    vertexBufferLoader._spzLoader = spzLoader;
+    await spzLoader.load();
+
+    if (vertexBufferLoader.isDestroyed()) {
+      return;
+    }
+
+    vertexBufferLoader._state = ResourceLoaderState.LOADED;
+    return vertexBufferLoader;
+  } catch {
+    if (vertexBufferLoader.isDestroyed()) {
+      return;
+    }
+  }
+}
+
+function processSpz(vertexBufferLoader) {
+  vertexBufferLoader._state = ResourceLoaderState.PROCESSING;
+  const spzLoader = vertexBufferLoader._spzLoader;
+
+  const gcloudData = spzLoader.decodedData.gcloud;
+
+  if (vertexBufferLoader._attributeSemantic === "POSITION") {
+    vertexBufferLoader._typedArray = gcloudData.positions;
+  } else if (vertexBufferLoader._attributeSemantic === "_SCALE") {
+    vertexBufferLoader._typedArray = gcloudData.scales;
+  } else if (vertexBufferLoader._attributeSemantic === "_ROTATION") {
+    vertexBufferLoader._typedArray = gcloudData.rotations;
+  } else if (vertexBufferLoader._attributeSemantic === "COLOR_0") {
+    const colors = gcloudData.colors;
+    const alphas = gcloudData.alphas;
+    vertexBufferLoader._typedArray = new Uint8Array((colors.length / 3) * 4);
+    for (let i = 0; i < colors.length / 3; i++) {
+      vertexBufferLoader._typedArray[i * 4] = CesiumMath.clamp(
+        colors[i * 3] * 255.0,
+        0.0,
+        255.0,
+      );
+      vertexBufferLoader._typedArray[i * 4 + 1] = CesiumMath.clamp(
+        colors[i * 3 + 1] * 255.0,
+        0.0,
+        255.0,
+      );
+      vertexBufferLoader._typedArray[i * 4 + 2] = CesiumMath.clamp(
+        colors[i * 3 + 2] * 255.0,
+        0.0,
+        255.0,
+      );
+      vertexBufferLoader._typedArray[i * 4 + 3] = CesiumMath.clamp(
+        alphas[i] * 255.0,
+        0.0,
+        255.0,
+      );
+    }
+  }
+}
+
 async function loadFromDraco(vertexBufferLoader) {
   vertexBufferLoader._state = ResourceLoaderState.LOADING;
   const resourceCache = vertexBufferLoader._resourceCache;
@@ -427,6 +504,19 @@ GltfVertexBufferLoader.prototype.process = function (frameState) {
     processDraco(this);
   }
 
+  if (defined(this._spzLoader)) {
+    try {
+      const ready = this._spzLoader.process(frameState);
+      if (!ready) {
+        return false;
+      }
+    } catch (error) {
+      handleError(this, error);
+    }
+
+    processSpz(this);
+  }
+
   let buffer;
   const typedArray = this._typedArray;
   if (this._loadBuffer && this._asynchronous) {
@@ -474,8 +564,13 @@ GltfVertexBufferLoader.prototype.unload = function () {
     resourceCache.unload(this._dracoLoader);
   }
 
+  if (defined(this._spzLoader)) {
+    resourceCache.unload(this._spzLoader);
+  }
+
   this._bufferViewLoader = undefined;
   this._dracoLoader = undefined;
+  this._spzLoader = undefined;
   this._typedArray = undefined;
   this._buffer = undefined;
   this._gltf = undefined;

package/Source/Scene/ImageryLayer.js

@@ -127,7 +127,7 @@ import TileImagery from "./TileImagery.js";
 
 /**
  * An imagery layer that displays tiled image data from a single imagery provider
- * on a {@link Globe}.
+ * on a {@link Globe} or {@link Cesium3DTileset}.
  *
  * @alias ImageryLayer
  * @constructor
@@ -135,8 +135,10 @@ import TileImagery from "./TileImagery.js";
  * @param {ImageryProvider} [imageryProvider] The imagery provider to use.
  * @param {ImageryLayer.ConstructorOptions} [options] An object describing initialization options
  *
- * @see ImageryLayer.fromProviderAsync
- * @see ImageryLayer.fromWorldImagery
+ * @see {@link ImageryLayer.fromProviderAsync} for creating an imagery layer from an asynchronous imagery provider.
+ * @see {@link ImageryLayer.fromWorldImagery} for creating an imagery layer for Cesium ion's default global base imagery layer.
+ * @see {@link Scene#imageryLayers} for adding an imagery layer to the globe.
+ * @see {@link Cesium3DTileset#imageryLayers} for adding an imagery layer to a 3D tileset.
  *
  * @example
  * // Add an OpenStreetMaps layer
@@ -155,6 +157,19 @@ import TileImagery from "./TileImagery.js";
  * 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);
  */
 function ImageryLayer(imageryProvider, options) {
   this._imageryProvider = imageryProvider;
@@ -663,7 +678,7 @@ ImageryLayer.prototype.getImageryRectangle = function () {
  *
  * @private
  *
- * @param {Tile} tile The terrain tile.
+ * @param {QuadtreeTile} tile The terrain tile.
  * @param {TerrainProvider|undefined} terrainProvider The terrain provider associated with the terrain tile.
  * @param {number} insertionPoint The position to insert new skeletons before in the tile's imagery list.
  * @returns {boolean} true if this layer overlaps any portion of the terrain tile; otherwise, false.

package/Source/Scene/ImageryLayerCollection.js

@@ -7,11 +7,12 @@ import Rectangle from "../Core/Rectangle.js";
 import ImageryLayer from "./ImageryLayer.js";
 
 /**
- * An ordered collection of imagery layers.
+ * An ordered collection of imagery layers for rendering raster imagery on a {@link Globe} or {@link Cesium3DTileset}.
  *
  * @alias ImageryLayerCollection
  * @constructor
- *
+ * @see {@link Scene#imageryLayers} for manipulating imagery layers on the globe.
+ * @see {@link Cesium3DTileset#imageryLayers} for manipulating imagery layers on a 3D tileset.
  * @demo {@link https://sandcastle.cesium.com/index.html?src=Imagery%20Adjustment.html|Cesium Sandcastle Imagery Adjustment Demo}
  * @demo {@link https://sandcastle.cesium.com/index.html?src=Imagery%20Layers%20Manipulation.html|Cesium Sandcastle Imagery Manipulation Demo}
  */

package/Source/Scene/Model/CartesianRectangle.js

@@ -0,0 +1,108 @@
+/**
+ * Internal class for texture coordinate and index range computations.
+ *
+ * @private
+ */
+class CartesianRectangle {
+  /**
+   * Creates a new instance
+   *
+   * @param {number} [minX=0] The minimum x-coordinate
+   * @param {number} [minY=0] The minimum y-coordinate
+   * @param {number} [maxX=0] The maximum x-coordinate
+   * @param {number} [maxY=0] The maximum y-coordinate
+   */
+  constructor(minX, minY, maxX, maxY) {
+    this._minX = minX ?? 0.0;
+    this._minY = minY ?? 0.0;
+    this._maxX = maxX ?? 0.0;
+    this._maxY = maxY ?? 0.0;
+  }
+
+  /**
+   * Returns the minimum x-coordinate
+   *
+   * @returns {number} The coordinate
+   */
+  get minX() {
+    return this._minX;
+  }
+  set minX(value) {
+    this._minX = value;
+  }
+
+  /**
+   * Returns the minimum y-coordinate
+   *
+   * @returns {number} The coordinate
+   */
+  get minY() {
+    return this._minY;
+  }
+  set minY(value) {
+    this._minY = value;
+  }
+
+  /**
+   * Returns the maximum x-coordinate
+   *
+   * @returns {number} The coordinate
+   */
+  get maxX() {
+    return this._maxX;
+  }
+  set maxX(value) {
+    this._maxX = value;
+  }
+
+  /**
+   * Returns the maximum y-coordinate
+   *
+   * @returns {number} The coordinate
+   */
+  get maxY() {
+    return this._maxY;
+  }
+  set maxY(value) {
+    this._maxY = value;
+  }
+
+  /**
+   * Returns whether this rectangle contains the given coordinates,
+   * using the default containment check, which includes the
+   * minimum point, but excludes the maximum point
+   *
+   * @param {number} x The x-coordinate
+   * @param {number} y The y-coordinate
+   * @returns {boolean} The result
+   */
+  contains(x, y) {
+    return x >= this.minX && x < this.maxX && y >= this.minY && y < this.maxY;
+  }
+
+  /**
+   * Returns whether this rectangle contains the given coordinates,
+   * excluding the border
+   *
+   * @param {number} x The x-coordinate
+   * @param {number} y The y-coordinate
+   * @returns {boolean} The result
+   */
+  containsExclusive(x, y) {
+    return x > this.minX && x < this.maxX && y > this.minY && y < this.maxY;
+  }
+
+  /**
+   * Returns whether this rectangle contains the given coordinates,
+   * including the border
+   *
+   * @param {number} x The x-coordinate
+   * @param {number} y The y-coordinate
+   * @returns {boolean} The result
+   */
+  containsInclusive(x, y) {
+    return x >= this.minX && x <= this.maxX && y >= this.minY && y <= this.maxY;
+  }
+}
+
+export default CartesianRectangle;

package/Source/Scene/Model/ImageryConfiguration.js

@@ -0,0 +1,25 @@
+/**
+ * A class containing a the values that affect the appearance of
+ * an <code>ImageryLayer</code>.
+ *
+ * This is used in the <code>ModelImagery</code> to detect changes in
+ * the imagery settings: The <code>ModelImagery</code> stores one
+ * instance per imagery layer. During the <code>update</code>
+ * call, it checks whether any of the settings was changed.
+ * If this is the case, the draw commands of the model are reset.
+ *
+ * @private
+ */
+class ImageryConfiguration {
+  constructor(imageryLayer) {
+    this.alpha = imageryLayer.alpha;
+    this.brightness = imageryLayer.brightness;
+    this.contrast = imageryLayer.contrast;
+    this.hue = imageryLayer.hue;
+    this.saturation = imageryLayer.saturation;
+    this.gamma = imageryLayer.gamma;
+    this.colorToAlpha = imageryLayer.colorToAlpha;
+  }
+}
+
+export default ImageryConfiguration;