@cesium/engine 2.2.0 → 2.4.0

package/Source/DataSources/EntityCluster.js

@@ -76,14 +76,6 @@ function EntityCluster(options) {
   this.show = defaultValue(options.show, true);
 }
 
-function getX(point) {
-  return point.coord.x;
-}
-
-function getY(point) {
-  return point.coord.y;
-}
-
 function expandBoundingBox(bbox, pixelRange) {
   bbox.x -= pixelRange;
   bbox.y -= pixelRange;
@@ -335,153 +327,159 @@ function createDeclutterCallback(entityCluster) {
     let collection;
     let collectionIndex;
 
-    const index = new KDBush(points, getX, getY, 64, Int32Array);
+    if (points.length > 0) {
+      const index = new KDBush(points.length, 64, Uint32Array);
+      for (let p = 0; p < points.length; ++p) {
+        index.add(points[p].coord.x, points[p].coord.y);
+      }
+      index.finish();
 
-    if (currentHeight < previousHeight) {
-      length = clusters.length;
-      for (i = 0; i < length; ++i) {
-        const cluster = clusters[i];
+      if (currentHeight < previousHeight) {
+        length = clusters.length;
+        for (i = 0; i < length; ++i) {
+          const cluster = clusters[i];
 
-        if (!occluder.isPointVisible(cluster.position)) {
-          continue;
+          if (!occluder.isPointVisible(cluster.position)) {
+            continue;
+          }
+
+          const coord = Billboard._computeScreenSpacePosition(
+            Matrix4.IDENTITY,
+            cluster.position,
+            Cartesian3.ZERO,
+            Cartesian2.ZERO,
+            scene
+          );
+          if (!defined(coord)) {
+            continue;
+          }
+
+          const factor = 1.0 - currentHeight / previousHeight;
+          let width = (cluster.width = cluster.width * factor);
+          let height = (cluster.height = cluster.height * factor);
+
+          width = Math.max(width, cluster.minimumWidth);
+          height = Math.max(height, cluster.minimumHeight);
+
+          const minX = coord.x - width * 0.5;
+          const minY = coord.y - height * 0.5;
+          const maxX = coord.x + width;
+          const maxY = coord.y + height;
+
+          neighbors = index.range(minX, minY, maxX, maxY);
+          neighborLength = neighbors.length;
+          numPoints = 0;
+          ids = [];
+
+          for (j = 0; j < neighborLength; ++j) {
+            neighborIndex = neighbors[j];
+            neighborPoint = points[neighborIndex];
+            if (!neighborPoint.clustered) {
+              ++numPoints;
+
+              collection = neighborPoint.collection;
+              collectionIndex = neighborPoint.index;
+              ids.push(collection.get(collectionIndex).id);
+            }
+          }
+
+          if (numPoints >= minimumClusterSize) {
+            addCluster(cluster.position, numPoints, ids, entityCluster);
+            newClusters.push(cluster);
+
+            for (j = 0; j < neighborLength; ++j) {
+              points[neighbors[j]].clustered = true;
+            }
+          }
         }
+      }
 
-        const coord = Billboard._computeScreenSpacePosition(
-          Matrix4.IDENTITY,
-          cluster.position,
-          Cartesian3.ZERO,
-          Cartesian2.ZERO,
-          scene
-        );
-        if (!defined(coord)) {
+      length = points.length;
+      for (i = 0; i < length; ++i) {
+        const point = points[i];
+        if (point.clustered) {
           continue;
         }
 
-        const factor = 1.0 - currentHeight / previousHeight;
-        let width = (cluster.width = cluster.width * factor);
-        let height = (cluster.height = cluster.height * factor);
+        point.clustered = true;
 
-        width = Math.max(width, cluster.minimumWidth);
-        height = Math.max(height, cluster.minimumHeight);
+        collection = point.collection;
+        collectionIndex = point.index;
 
-        const minX = coord.x - width * 0.5;
-        const minY = coord.y - height * 0.5;
-        const maxX = coord.x + width;
-        const maxY = coord.y + height;
+        const item = collection.get(collectionIndex);
+        bbox = getBoundingBox(
+          item,
+          point.coord,
+          pixelRange,
+          entityCluster,
+          pointBoundinRectangleScratch
+        );
+        const totalBBox = BoundingRectangle.clone(
+          bbox,
+          totalBoundingRectangleScratch
+        );
 
-        neighbors = index.range(minX, minY, maxX, maxY);
+        neighbors = index.range(
+          bbox.x,
+          bbox.y,
+          bbox.x + bbox.width,
+          bbox.y + bbox.height
+        );
         neighborLength = neighbors.length;
-        numPoints = 0;
-        ids = [];
+
+        const clusterPosition = Cartesian3.clone(item.position);
+        numPoints = 1;
+        ids = [item.id];
 
         for (j = 0; j < neighborLength; ++j) {
           neighborIndex = neighbors[j];
           neighborPoint = points[neighborIndex];
           if (!neighborPoint.clustered) {
+            const neighborItem = neighborPoint.collection.get(
+              neighborPoint.index
+            );
+            const neighborBBox = getBoundingBox(
+              neighborItem,
+              neighborPoint.coord,
+              pixelRange,
+              entityCluster,
+              neighborBoundingRectangleScratch
+            );
+
+            Cartesian3.add(
+              neighborItem.position,
+              clusterPosition,
+              clusterPosition
+            );
+
+            BoundingRectangle.union(totalBBox, neighborBBox, totalBBox);
             ++numPoints;
 
-            collection = neighborPoint.collection;
-            collectionIndex = neighborPoint.index;
-            ids.push(collection.get(collectionIndex).id);
+            ids.push(neighborItem.id);
           }
         }
 
         if (numPoints >= minimumClusterSize) {
-          addCluster(cluster.position, numPoints, ids, entityCluster);
-          newClusters.push(cluster);
-
-          for (j = 0; j < neighborLength; ++j) {
-            points[neighbors[j]].clustered = true;
-          }
-        }
-      }
-    }
-
-    length = points.length;
-    for (i = 0; i < length; ++i) {
-      const point = points[i];
-      if (point.clustered) {
-        continue;
-      }
-
-      point.clustered = true;
-
-      collection = point.collection;
-      collectionIndex = point.index;
-
-      const item = collection.get(collectionIndex);
-      bbox = getBoundingBox(
-        item,
-        point.coord,
-        pixelRange,
-        entityCluster,
-        pointBoundinRectangleScratch
-      );
-      const totalBBox = BoundingRectangle.clone(
-        bbox,
-        totalBoundingRectangleScratch
-      );
-
-      neighbors = index.range(
-        bbox.x,
-        bbox.y,
-        bbox.x + bbox.width,
-        bbox.y + bbox.height
-      );
-      neighborLength = neighbors.length;
-
-      const clusterPosition = Cartesian3.clone(item.position);
-      numPoints = 1;
-      ids = [item.id];
-
-      for (j = 0; j < neighborLength; ++j) {
-        neighborIndex = neighbors[j];
-        neighborPoint = points[neighborIndex];
-        if (!neighborPoint.clustered) {
-          const neighborItem = neighborPoint.collection.get(
-            neighborPoint.index
-          );
-          const neighborBBox = getBoundingBox(
-            neighborItem,
-            neighborPoint.coord,
-            pixelRange,
-            entityCluster,
-            neighborBoundingRectangleScratch
-          );
-
-          Cartesian3.add(
-            neighborItem.position,
+          const position = Cartesian3.multiplyByScalar(
             clusterPosition,
+            1.0 / numPoints,
             clusterPosition
           );
+          addCluster(position, numPoints, ids, entityCluster);
+          newClusters.push({
+            position: position,
+            width: totalBBox.width,
+            height: totalBBox.height,
+            minimumWidth: bbox.width,
+            minimumHeight: bbox.height,
+          });
 
-          BoundingRectangle.union(totalBBox, neighborBBox, totalBBox);
-          ++numPoints;
-
-          ids.push(neighborItem.id);
-        }
-      }
-
-      if (numPoints >= minimumClusterSize) {
-        const position = Cartesian3.multiplyByScalar(
-          clusterPosition,
-          1.0 / numPoints,
-          clusterPosition
-        );
-        addCluster(position, numPoints, ids, entityCluster);
-        newClusters.push({
-          position: position,
-          width: totalBBox.width,
-          height: totalBBox.height,
-          minimumWidth: bbox.width,
-          minimumHeight: bbox.height,
-        });
-
-        for (j = 0; j < neighborLength; ++j) {
-          points[neighbors[j]].clustered = true;
+          for (j = 0; j < neighborLength; ++j) {
+            points[neighbors[j]].clustered = true;
+          }
+        } else {
+          addNonClusteredItem(item, entityCluster);
         }
-      } else {
-        addNonClusteredItem(item, entityCluster);
       }
     }
 

package/Source/DataSources/ModelVisualizer.js

@@ -63,6 +63,7 @@ function ModelVisualizer(scene, entityCollection) {
   this._entityCollection = entityCollection;
   this._modelHash = {};
   this._entitiesToVisualize = new AssociativeArray();
+
   this._onCollectionChanged(entityCollection, entityCollection.values, [], []);
 }
 
@@ -444,11 +445,12 @@ ModelVisualizer.prototype.getBoundingSphere = function (entity, result) {
 
   const scene = this._scene;
   const globe = scene.globe;
-  const ellipsoid = globe.ellipsoid;
-  const terrainProvider = globe.terrainProvider;
 
+  // cannot access a terrain provider if there is no globe; formally set to undefined
+  const terrainProvider = defined(globe) ? globe.terrainProvider : undefined;
   const hasHeightReference = model.heightReference !== HeightReference.NONE;
-  if (hasHeightReference) {
+  if (defined(globe) && hasHeightReference) {
+    const ellipsoid = globe.ellipsoid;
     // We cannot query the availability of the terrain provider till its ready, so the
     // bounding sphere state will remain pending till the terrain provider is ready.
     // ready is deprecated. This is here for backwards compatibility

package/Source/Renderer/UniformState.js

@@ -1173,8 +1173,9 @@ UniformState.prototype.updateFrustum = function (frustum) {
   this._oneOverLog2FarDepthFromNearPlusOne =
     1.0 / this._log2FarDepthFromNearPlusOne;
 
-  if (defined(frustum._offCenterFrustum)) {
-    frustum = frustum._offCenterFrustum;
+  const offCenterFrustum = frustum.offCenterFrustum;
+  if (defined(offCenterFrustum)) {
+    frustum = offCenterFrustum;
   }
 
   this._frustumPlanes.x = frustum.top;

package/Source/Renderer/demodernizeShader.js

@@ -41,16 +41,16 @@ function demodernizeShader(input, isFragmentShader) {
       output = output.replaceAll(/out_FragData_(\d+)/g, `gl_FragData[$1]`);
     }
 
-    // Replace out_FragColor with gl_FragColor.
-    output = output.replaceAll(/out_FragColor/g, `gl_FragColor`);
-    output = output.replaceAll(/out_FragColor\[(\d+)\]/g, `gl_FragColor[$1]`);
-
     // Remove all layout declarations for out_FragColor.
     output = output.replaceAll(
-      /layout\s+\(location\s*=\s*0\)\s*out\s+vec4\s+out_FragColor/g,
+      /layout\s+\(location\s*=\s*0\)\s*out\s+vec4\s+out_FragColor;/g,
       ``
     );
 
+    // Replace out_FragColor with gl_FragColor.
+    output = output.replaceAll(/out_FragColor/g, `gl_FragColor`);
+    output = output.replaceAll(/out_FragColor\[(\d+)\]/g, `gl_FragColor[$1]`);
+
     if (/gl_FragDepth/.test(output)) {
       output = `#extension GL_EXT_frag_depth : enable\n${output}`;
       // Replace gl_FragDepth with gl_FragDepthEXT.

package/Source/Scene/ArcGisBaseMapType.js

@@ -0,0 +1,12 @@
+/**
+ * ArcGisBaseMapType enumerates the ArcGIS image tile layers that are supported by default.
+ *
+ * @enum {number}
+ * @see ArcGisMapServerImageryProvider
+ */
+const ArcGisBaseMapType = {
+  SATELLITE: 1,
+  OCEANS: 2,
+  HILLSHADE: 3,
+};
+export default Object.freeze(ArcGisBaseMapType);

package/Source/Scene/ArcGisMapServerImageryProvider.js

@@ -16,9 +16,12 @@ import RuntimeError from "../Core/RuntimeError.js";
 import TileProviderError from "../Core/TileProviderError.js";
 import WebMercatorProjection from "../Core/WebMercatorProjection.js";
 import WebMercatorTilingScheme from "../Core/WebMercatorTilingScheme.js";
+import ArcGisMapService from "./ArcGisMapService.js";
 import DiscardMissingTileImagePolicy from "./DiscardMissingTileImagePolicy.js";
 import ImageryLayerFeatureInfo from "./ImageryLayerFeatureInfo.js";
 import ImageryProvider from "./ImageryProvider.js";
+import ArcGisBaseMapType from "./ArcGisBaseMapType.js";
+import DeveloperError from "../Core/DeveloperError.js";
 
 /**
  * @typedef {object} ArcGisMapServerImageryProvider.ConstructorOptions
@@ -39,8 +42,7 @@ import ImageryProvider from "./ImageryProvider.js";
  *        that no tiles are discarded, construct and pass a {@link NeverTileDiscardPolicy} for this
  *        parameter.
  * @property {boolean} [usePreCachedTilesIfAvailable=true] If true, the server's pre-cached
- *        tiles are used if they are available.  If false, any pre-cached tiles are ignored and the
- *        'export' service is used.
+ *        tiles are used if they are available. Exporting Tiles is only supported with deprecated APIs.
  * @property {string} [layers] A comma-separated list of the layers to show, or undefined if all layers should be shown.
  * @property {boolean} [enablePickFeatures=true] If true, {@link ArcGisMapServerImageryProvider#pickFeatures} will invoke
  *        the Identify service on the MapServer and return the features included in the response.  If false,
@@ -59,6 +61,8 @@ import ImageryProvider from "./ImageryProvider.js";
  * @property {number} [tileHeight=256] The height of each tile in pixels.  This parameter is ignored when accessing a tiled server.
  * @property {number} [maximumLevel] The maximum tile level to request, or undefined if there is no maximum.  This parameter is ignored when accessing
  *                                        a tiled server.
+ *
+ *
  */
 
 /**
@@ -85,6 +89,7 @@ function ImageryProviderBuilder(options) {
     credit = new Credit(credit);
   }
   this.credit = credit;
+  this.tileCredits = undefined;
   this.tileDiscardPolicy = options.tileDiscardPolicy;
 
   this.tileWidth = defaultValue(options.tileWidth, 256);
@@ -104,6 +109,7 @@ ImageryProviderBuilder.prototype.build = function (provider) {
   provider._tilingScheme = this.tilingScheme;
   provider._rectangle = this.rectangle;
   provider._credit = this.credit;
+  provider._tileCredits = this.tileCredits;
   provider._tileDiscardPolicy = this.tileDiscardPolicy;
   provider._tileWidth = this.tileWidth;
   provider._tileHeight = this.tileHeight;
@@ -221,7 +227,11 @@ function metadataSuccess(data, imageryProviderBuilder) {
   }
 
   if (defined(data.copyrightText) && data.copyrightText.length > 0) {
-    imageryProviderBuilder.credit = new Credit(data.copyrightText);
+    if (defined(imageryProviderBuilder.credit)) {
+      imageryProviderBuilder.tileCredits = [new Credit(data.copyrightText)];
+    } else {
+      imageryProviderBuilder.credit = new Credit(data.copyrightText);
+    }
   }
 }
 
@@ -255,7 +265,7 @@ async function requestMetadata(resource, imageryProviderBuilder, provider) {
   });
 
   try {
-    const data = await jsonResource.fetchJsonp();
+    const data = await jsonResource.fetchJson();
     metadataSuccess(data, imageryProviderBuilder);
   } catch (error) {
     metadataFailure(resource, error, provider);
@@ -264,34 +274,49 @@ async function requestMetadata(resource, imageryProviderBuilder, provider) {
 
 /**
  * <div class="notice">
- * To construct a ArcGisMapServerImageryProvider call {@link ArcGisMapServerImageryProvider.fromUrl}. Do not call the constructor directly.
+ * This object is normally not instantiated directly, use {@link ArcGisMapServerImageryProvider.fromBasemapType} or {@link ArcGisMapServerImageryProvider.fromUrl}.
  * </div>
  *
  * Provides tiled imagery hosted by an ArcGIS MapServer.  By default, the server's pre-cached tiles are
  * used, if available.
+ * 
+ * <br/>
+ * 
+ * An {@link https://developers.arcgis.com/documentation/mapping-apis-and-services/security| ArcGIS Access Token } is required to authenticate requests to an ArcGIS Image Tile service.
+ * To access secure ArcGIS resources, it's required to create an ArcGIS developer
+ * account or an ArcGIS online account, then implement an authentication method to obtain an access token.
  *
  * @alias ArcGisMapServerImageryProvider
  * @constructor
  *
  * @param {ArcGisMapServerImageryProvider.ConstructorOptions} [options] Object describing initialization options
  *
- * @see ArcGisMapServerImagery.fromUrl
- * @see BingMapsImageryProvider
- * @see GoogleEarthEnterpriseMapsProvider
- * @see OpenStreetMapImageryProvider
- * @see SingleTileImageryProvider
- * @see TileMapServiceImageryProvider
- * @see WebMapServiceImageryProvider
- * @see WebMapTileServiceImageryProvider
- * @see UrlTemplateImageryProvider
+ * @see ArcGisMapServerImageryProvider.fromBasemapType
+ * @see ArcGisMapServerImageryProvider.fromUrl
+ *
+ * @example
+ * // Set the default access token for accessing ArcGIS Image Tile service
+ * Cesium.ArcGisMapService.defaultAccessToken = "<ArcGIS Access Token>";
+ * 
+ * // Add a base layer from a default ArcGIS basemap
+ * const viewer = new Cesium.Viewer("cesiumContainer", {
+ *   baseLayer: Cesium.ImageryLayer.fromProviderAsync(
+ *     Cesium.ArcGisMapServerImageryProvider.fromBasemapType(
+ *       Cesium.ArcGisBaseMapType.SATELLITE
+ *     )
+ *   ),
+ * });
  *
  * @example
+ * // Create an imagery provider from the url directly
  * const esri = await Cesium.ArcGisMapServerImageryProvider.fromUrl(
- *     "https://services.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer"
- * );
+ *   "https://ibasemaps-api.arcgis.com/arcgis/rest/services/World_Imagery/MapServer", {
+ *     token: "<ArcGIS Access Token>"
+ * });
  *
  * @see {@link https://developers.arcgis.com/rest/|ArcGIS Server REST API}
- * @see {@link http://www.w3.org/TR/cors/|Cross-Origin Resource Sharing}
+ * @see {@link https://developers.arcgis.com/documentation/mapping-apis-and-services/security| ArcGIS Access Token }
+
  */
 function ArcGisMapServerImageryProvider(options) {
   options = defaultValue(options, defaultValue.EMPTY_OBJECT);
@@ -321,7 +346,13 @@ function ArcGisMapServerImageryProvider(options) {
     this._tilingScheme.rectangle
   );
   this._layers = options.layers;
-  this._credit = undefined;
+  this._credit = options.credit;
+  this._tileCredits = undefined;
+
+  let credit = options.credit;
+  if (typeof credit === "string") {
+    credit = new Credit(credit);
+  }
 
   /**
    * Gets or sets a value indicating whether feature picking is enabled.  If true, {@link ArcGisMapServerImageryProvider#pickFeatures} will
@@ -371,6 +402,117 @@ function ArcGisMapServerImageryProvider(options) {
   }
 }
 
+/**
+ * Creates an {@link ImageryProvider} which provides tiled imagery from an ArcGIS base map.
+ * @param {ArcGisBaseMapType} style The style of the ArcGIS base map imagery. Valid options are {@link ArcGisBaseMapType.SATELLITE}, {@link ArcGisBaseMapType.OCEANS}, and {@link ArcGisBaseMapType.HILLSHADE}.
+ * @param {ArcGisMapServerImageryProvider.ConstructorOptions} [options] Object describing initialization options.
+ * @returns {Promise<ArcGisMapServerImageryProvider>} A promise that resolves to the created ArcGisMapServerImageryProvider.
+ *
+ * @example
+ * // Set the default access token for accessing ArcGIS Image Tile service
+ * Cesium.ArcGisMapService.defaultAccessToken = "<ArcGIS Access Token>";
+ *
+ * // Add a base layer from a default ArcGIS basemap
+ * const provider = await Cesium.ArcGisMapServerImageryProvider.fromBasemapType(
+ *   Cesium.ArcGisBaseMapType.SATELLITE);
+ *
+ * @example
+ * // Add a base layer from a default ArcGIS Basemap
+ * const viewer = new Cesium.Viewer("cesiumContainer", {
+ *   baseLayer: Cesium.ImageryLayer.fromProviderAsync(
+ *     Cesium.ArcGisMapServerImageryProvider.fromBasemapType(
+ *       Cesium.ArcGisBaseMapType.HILLSHADE, {
+ *         token: "<ArcGIS Access Token>"
+ *       }
+ *     )
+ *   ),
+ * });
+ */
+
+ArcGisMapServerImageryProvider.fromBasemapType = async function (
+  style,
+  options
+) {
+  //>>includeStart('debug', pragmas.debug);
+  Check.defined("style", style);
+  //>>includeEnd('debug');
+
+  options = defaultValue(options, defaultValue.EMPTY_OBJECT);
+  let accessToken;
+  let server;
+  let warningCredit;
+  switch (style) {
+    case ArcGisBaseMapType.SATELLITE:
+      {
+        accessToken = defaultValue(
+          options.token,
+          ArcGisMapService.defaultAccessToken
+        );
+        server = Resource.createIfNeeded(
+          defaultValue(options.url, ArcGisMapService.defaultWorldImageryServer)
+        );
+        server.appendForwardSlash();
+        const defaultTokenCredit = ArcGisMapService.getDefaultTokenCredit(
+          accessToken
+        );
+        if (defined(defaultTokenCredit)) {
+          warningCredit = Credit.clone(defaultTokenCredit);
+        }
+      }
+      break;
+    case ArcGisBaseMapType.OCEANS:
+      {
+        accessToken = defaultValue(
+          options.token,
+          ArcGisMapService.defaultAccessToken
+        );
+        server = Resource.createIfNeeded(
+          defaultValue(options.url, ArcGisMapService.defaultWorldOceanServer)
+        );
+        server.appendForwardSlash();
+        const defaultTokenCredit = ArcGisMapService.getDefaultTokenCredit(
+          accessToken
+        );
+        if (defined(defaultTokenCredit)) {
+          warningCredit = Credit.clone(defaultTokenCredit);
+        }
+      }
+      break;
+    case ArcGisBaseMapType.HILLSHADE:
+      {
+        accessToken = defaultValue(
+          options.token,
+          ArcGisMapService.defaultAccessToken
+        );
+        server = Resource.createIfNeeded(
+          defaultValue(
+            options.url,
+            ArcGisMapService.defaultWorldHillshadeServer
+          )
+        );
+        server.appendForwardSlash();
+        const defaultTokenCredit = ArcGisMapService.getDefaultTokenCredit(
+          accessToken
+        );
+        if (defined(defaultTokenCredit)) {
+          warningCredit = Credit.clone(defaultTokenCredit);
+        }
+      }
+      break;
+    default:
+      //>>includeStart('debug', pragmas.debug);
+      throw new DeveloperError(`Unsupported basemap type: ${style}`);
+    //>>includeEnd('debug');
+  }
+
+  return ArcGisMapServerImageryProvider.fromUrl(server, {
+    ...options,
+    token: accessToken,
+    credit: warningCredit,
+    usePreCachedTilesIfAvailable: true, // ArcGIS Base Map Service Layers only support Tiled views
+  });
+};
+
 function buildImageResource(imageryProvider, x, y, level, request) {
   let resource;
   if (imageryProvider._useTiles) {
@@ -413,7 +555,6 @@ function buildImageResource(imageryProvider, x, y, level, request) {
       queryParameters: query,
     });
   }
-
   return resource;
 }
 
@@ -941,7 +1082,7 @@ ArcGisMapServerImageryProvider.prototype.getTileCredits = function (
   y,
   level
 ) {
-  return undefined;
+  return this._tileCredits;
 };
 
 /**
@@ -1078,4 +1219,5 @@ ArcGisMapServerImageryProvider.prototype.pickFeatures = function (
     return result;
   });
 };
+ArcGisMapServerImageryProvider._metadataCache = {};
 export default ArcGisMapServerImageryProvider;