@cesium/engine 21.0.1-ion.0 → 22.0.0

package/Source/Scene/IonImageryProvider.js

@@ -1,72 +1,11 @@
 import Check from "../Core/Check.js";
+import clone from "../Core/clone.js";
 import Frozen from "../Core/Frozen.js";
 import defined from "../Core/defined.js";
 import Event from "../Core/Event.js";
 import IonResource from "../Core/IonResource.js";
 import RuntimeError from "../Core/RuntimeError.js";
-import ArcGisMapServerImageryProvider from "./ArcGisMapServerImageryProvider.js";
-import BingMapsImageryProvider from "./BingMapsImageryProvider.js";
-import TileMapServiceImageryProvider from "./TileMapServiceImageryProvider.js";
-import GoogleEarthEnterpriseMapsProvider from "./GoogleEarthEnterpriseMapsProvider.js";
-import MapboxImageryProvider from "./MapboxImageryProvider.js";
-import SingleTileImageryProvider from "./SingleTileImageryProvider.js";
-import UrlTemplateImageryProvider from "./UrlTemplateImageryProvider.js";
-import WebMapServiceImageryProvider from "./WebMapServiceImageryProvider.js";
-import WebMapTileServiceImageryProvider from "./WebMapTileServiceImageryProvider.js";
-import Google2DImageryProvider from "./Google2DImageryProvider.js";
-import Azure2DImageryProvider from "./Azure2DImageryProvider.js";
-
-// These values are the list of supported external imagery
-// assets in the Cesium ion beta. They are subject to change.
-const ImageryProviderAsyncMapping = {
-  ARCGIS_MAPSERVER: ArcGisMapServerImageryProvider.fromUrl,
-  BING: async (url, options) => {
-    return BingMapsImageryProvider.fromUrl(url, options);
-  },
-  GOOGLE_EARTH: async (url, options) => {
-    const channel = options.channel;
-    delete options.channel;
-    return GoogleEarthEnterpriseMapsProvider.fromUrl(url, channel, options);
-  },
-  MAPBOX: (url, options) => {
-    return new MapboxImageryProvider({
-      url: url,
-      ...options,
-    });
-  },
-  SINGLE_TILE: SingleTileImageryProvider.fromUrl,
-  TMS: TileMapServiceImageryProvider.fromUrl,
-  URL_TEMPLATE: (url, options) => {
-    return new UrlTemplateImageryProvider({
-      url: url,
-      ...options,
-    });
-  },
-  WMS: (url, options) => {
-    return new WebMapServiceImageryProvider({
-      url: url,
-      ...options,
-    });
-  },
-  WMTS: (url, options) => {
-    return new WebMapTileServiceImageryProvider({
-      url: url,
-      ...options,
-    });
-  },
-  GOOGLE_2D_MAPS: (ionResource, options) => {
-    return new Google2DImageryProvider({
-      ...options,
-      url: ionResource,
-    });
-  },
-  AZURE_MAPS: (ionResource, options) => {
-    return new Azure2DImageryProvider({
-      ...options,
-      url: ionResource,
-    });
-  },
-};
+import IonImageryProviderFactory from "./IonImageryProviderFactory.js";
 
 /**
  * @typedef {object} IonImageryProvider.ConstructorOptions
@@ -264,7 +203,7 @@ Object.defineProperties(IonImageryProvider.prototype, {
 /**
  * Creates a provider for tiled imagery using the Cesium ion REST API.
  *
- * @param {Number} assetId  An ion imagery asset ID.
+ * @param {number} assetId  An ion imagery asset ID.
  * @param {IonImageryProvider.ConstructorOptions} [options] Object describing initialization options.
  * @returns {Promise<IonImageryProvider>} A promise which resolves to the created IonImageryProvider.
  *
@@ -297,41 +236,33 @@ IonImageryProvider.fromAssetId = async function (assetId, options) {
     IonImageryProvider._endpointCache[cacheKey] = promise;
   }
 
-  const endpoint = await promise;
+  let endpoint = await promise;
   if (endpoint.type !== "IMAGERY") {
     throw new RuntimeError(
       `Cesium ion asset ${assetId} is not an imagery asset.`,
     );
   }
 
-  let imageryProvider;
   const externalType = endpoint.externalType;
-  if (!defined(externalType)) {
-    imageryProvider = await TileMapServiceImageryProvider.fromUrl(
-      new IonResource(endpoint, endpointResource),
-    );
-  } else {
-    const factory = ImageryProviderAsyncMapping[externalType];
+  let factory = IonImageryProviderFactory.defaultFactoryCallback;
+
+  // Make a copy before editing since this object reference is cached;
+  endpoint = clone(endpoint, true);
+  endpoint.options = endpoint.options ?? {};
+  const url = endpoint.options?.url;
+  delete options.url;
+
+  if (defined(externalType)) {
+    factory = IonImageryProviderFactory[externalType];
 
     if (!defined(factory)) {
       throw new RuntimeError(
         `Unrecognized Cesium ion imagery type: ${externalType}`,
       );
     }
-    // Make a copy before editing since this object reference is cached;
-    const options = { ...endpoint.options };
-    const url = options.url;
-    delete options.url;
-    if (["GOOGLE_2D_MAPS", "AZURE_MAPS"].includes(endpoint.externalType)) {
-      imageryProvider = await factory(
-        new IonResource(endpoint, endpointResource),
-        options,
-      );
-    } else {
-      imageryProvider = await factory(url, options);
-    }
   }
 
+  const imageryProvider = await factory(url, endpoint, endpointResource);
   const provider = new IonImageryProvider(options);
 
   imageryProvider.errorEvent.addEventListener(function (tileProviderError) {

package/Source/Scene/IonImageryProviderFactory.js

@@ -0,0 +1,194 @@
+import IonResource from "../Core/IonResource.js";
+import ArcGisMapServerImageryProvider from "./ArcGisMapServerImageryProvider.js";
+import BingMapsImageryProvider from "./BingMapsImageryProvider.js";
+import TileMapServiceImageryProvider from "./TileMapServiceImageryProvider.js";
+import GoogleEarthEnterpriseMapsProvider from "./GoogleEarthEnterpriseMapsProvider.js";
+import MapboxImageryProvider from "./MapboxImageryProvider.js";
+import SingleTileImageryProvider from "./SingleTileImageryProvider.js";
+import UrlTemplateImageryProvider from "./UrlTemplateImageryProvider.js";
+import WebMapServiceImageryProvider from "./WebMapServiceImageryProvider.js";
+import WebMapTileServiceImageryProvider from "./WebMapTileServiceImageryProvider.js";
+import Google2DImageryProvider from "./Google2DImageryProvider.js";
+import Azure2DImageryProvider from "./Azure2DImageryProvider.js";
+
+/**
+ * An asynchronous callback function that creates an ImageryProvider from
+ * a Cesium ion asset endpoint.
+ * @template {ImageryProvider} T
+ * @callback IonImageryProviderFactoryCallback
+ * @param {string} url The URL of the imagery service.
+ * @param {object} endpoint The result of the Cesium ion asset endpoint service.
+ * @param {Resource} endpointResource The original resource used to retrieve the endpoint.
+ * @returns {Promise<T>} A promise that resolves to an instance of an ImageryProvider.
+ * @private
+ */
+
+/**
+ * @private
+ * @type {IonImageryProviderFactoryCallback<TileMapServiceImageryProvider>}
+ */
+export const defaultFactoryCallback = async (url, endpoint, endpointResource) =>
+  TileMapServiceImageryProvider.fromUrl(
+    new IonResource(endpoint, endpointResource),
+  );
+
+/**
+ * @private
+ * @type {IonImageryProviderFactoryCallback<ArcGisMapServerImageryProvider>}
+ */
+export const ARCGIS_MAPSERVER = async (url, { options }) =>
+  ArcGisMapServerImageryProvider.fromUrl(url, options);
+
+/**
+ * @private
+ * @type {IonImageryProviderFactoryCallback<BingMapsImageryProvider>}
+ */
+export const BING = async (url, { options }) => {
+  return BingMapsImageryProvider.fromUrl(url, options);
+};
+
+/**
+ * @private
+ * @type {IonImageryProviderFactoryCallback<GoogleEarthEnterpriseMapsProvider>}
+ */
+export const GOOGLE_EARTH = async (url, { options }) => {
+  const channel = options.channel;
+  delete options.channel;
+  return GoogleEarthEnterpriseMapsProvider.fromUrl(url, channel, options);
+};
+
+/**
+ * @private
+ * @type {IonImageryProviderFactoryCallback<MapboxImageryProvider>}
+ */
+export const MAPBOX = async (url, { options }) => {
+  return new MapboxImageryProvider({
+    url: url,
+    ...options,
+  });
+};
+
+/**
+ * @private
+ * @type {IonImageryProviderFactoryCallback<SingleTileImageryProvider>}
+ */
+export const SINGLE_TILE = async (url, { options }) =>
+  SingleTileImageryProvider.fromUrl(url, options);
+
+/**
+ * @private
+ * @type {IonImageryProviderFactoryCallback<TileMapServiceImageryProvider>}
+ */
+export const TMS = async (url, { options }) =>
+  TileMapServiceImageryProvider.fromUrl(url, options);
+
+/**
+ * @private
+ * @type {IonImageryProviderFactoryCallback<UrlTemplateImageryProvider>}
+ */
+export const URL_TEMPLATE = async (url, { options }) => {
+  return new UrlTemplateImageryProvider({
+    url: url,
+    ...options,
+  });
+};
+
+/**
+ * @private
+ * @type {IonImageryProviderFactoryCallback<WebMapServiceImageryProvider>}
+ */
+export const WMS = async (url, { options }) => {
+  return new WebMapServiceImageryProvider({
+    url: url,
+    ...options,
+  });
+};
+
+/**
+ * @private
+ * @type {IonImageryProviderFactoryCallback<WebMapTileServiceImageryProvider>}
+ */
+export const WMTS = async (url, { options }) => {
+  return new WebMapTileServiceImageryProvider({
+    url: url,
+    ...options,
+  });
+};
+
+/**
+ * @private
+ * @type {IonImageryProviderFactoryCallback<Google2DImageryProvider>}
+ */
+export const GOOGLE_2D_MAPS = async (url, endpoint, endpointResource) => {
+  delete endpoint.externalType;
+  endpoint.url = url;
+
+  const ionResource = new IonResource(endpoint, endpointResource);
+
+  const callback = (ionRoot, endpoint) => {
+    delete endpoint.externalType;
+    endpoint.url = url;
+
+    const { options } = endpoint;
+    ionRoot.setQueryParameters({
+      session: options.session,
+      key: options.key,
+    });
+  };
+
+  ionResource.refreshCallback = callback;
+  return new Google2DImageryProvider({
+    ...endpoint.options,
+    url: ionResource,
+  });
+};
+
+/**
+ * @private
+ * @type {IonImageryProviderFactoryCallback<Azure2DImageryProvider>}
+ */
+export const AZURE_MAPS = async (url, endpoint, endpointResource) => {
+  delete endpoint.externalType;
+  endpoint.url = url;
+
+  const ionResource = new IonResource(endpoint, endpointResource);
+
+  const callback = (ionRoot, endpoint) => {
+    delete endpoint.externalType;
+    endpoint.url = url;
+
+    const { options } = endpoint;
+    ionRoot.setQueryParameters({
+      "subscription-key": options["subscription-key"],
+    });
+  };
+
+  ionResource.refreshCallback = callback;
+  return new Azure2DImageryProvider({
+    ...endpoint.options,
+    url: ionResource,
+  });
+};
+
+/**
+ * Mapping of supported external imagery asset types returned from Cesium ion to their
+ * corresponding ImageryProvider constructors.
+ * @private
+ * @type {object<string, IonImageryProviderFactoryCallback>}
+ */
+const IonImageryProviderFactory = {
+  ARCGIS_MAPSERVER,
+  BING,
+  GOOGLE_EARTH,
+  MAPBOX,
+  SINGLE_TILE,
+  TMS,
+  URL_TEMPLATE,
+  WMS,
+  WMTS,
+  GOOGLE_2D_MAPS,
+  AZURE_MAPS,
+  defaultFactoryCallback,
+};
+
+export default Object.freeze(IonImageryProviderFactory);

package/Source/Scene/LabelCollection.js

@@ -150,47 +150,25 @@ function rebindAllGlyphs(labelCollection, label) {
   // presize glyphs to match the new text length
   glyphs.length = textLength;
 
-  const showBackground =
-    label.show && label._showBackground && text.split("\n").join("").length > 0;
   let backgroundBillboard = label._backgroundBillboard;
   const backgroundBillboardCollection =
     labelCollection._backgroundBillboardCollection;
-  if (!showBackground) {
-    if (defined(backgroundBillboard)) {
-      backgroundBillboardCollection.remove(backgroundBillboard);
-      label._backgroundBillboard = backgroundBillboard = undefined;
-    }
-  } else {
-    if (!defined(backgroundBillboard)) {
-      backgroundBillboard = getWhitePixelBillboard(
-        backgroundBillboardCollection,
-        labelCollection,
-      );
-      label._backgroundBillboard = backgroundBillboard;
-    }
 
-    backgroundBillboard.color = label._backgroundColor;
-    backgroundBillboard.show = label._show;
-    backgroundBillboard.position = label._position;
-    backgroundBillboard.eyeOffset = label._eyeOffset;
-    backgroundBillboard.pixelOffset = label._pixelOffset;
-    backgroundBillboard.horizontalOrigin = HorizontalOrigin.LEFT;
-    backgroundBillboard.verticalOrigin = label._verticalOrigin;
-    backgroundBillboard.heightReference = label._heightReference;
-    backgroundBillboard.scale = label.totalScale;
-    backgroundBillboard.pickPrimitive = label;
-    backgroundBillboard.id = label._id;
-    backgroundBillboard.translucencyByDistance = label._translucencyByDistance;
-    backgroundBillboard.pixelOffsetScaleByDistance =
-      label._pixelOffsetScaleByDistance;
-    backgroundBillboard.scaleByDistance = label._scaleByDistance;
-    backgroundBillboard.distanceDisplayCondition =
-      label._distanceDisplayCondition;
-    backgroundBillboard.disableDepthTestDistance =
-      label._disableDepthTestDistance;
-    backgroundBillboard.clusterShow = label.clusterShow;
+  // Create backgroundBillboard if needed
+  if (label._showBackground && !defined(backgroundBillboard)) {
+    backgroundBillboard = getWhitePixelBillboard(
+      backgroundBillboardCollection,
+      labelCollection,
+    );
+    label._backgroundBillboard = backgroundBillboard;
   }
 
+  updateBackgroundBillboard(
+    backgroundBillboardCollection,
+    label,
+    backgroundBillboard,
+  );
+
   const glyphBillboardCollection = labelCollection._glyphBillboardCollection;
   const glyphTextureCache = glyphBillboardCollection.billboardTextureCache;
   const textDimensionsCache = labelCollection._textDimensionsCache;
@@ -335,6 +313,47 @@ function rebindAllGlyphs(labelCollection, label) {
   label._repositionAllGlyphs = true;
 }
 
+function updateBackgroundBillboard(
+  backgroundBillboardCollection,
+  label,
+  backgroundBillboard,
+) {
+  if (!defined(backgroundBillboard)) {
+    return;
+  }
+  const showBackground =
+    label.show &&
+    label._showBackground &&
+    label._renderedText.split("\n").join("").length > 0;
+  // Label is shown and background is hidden - remove the background billboard
+  if (label.show && !showBackground) {
+    backgroundBillboardCollection.remove(backgroundBillboard);
+    label._backgroundBillboard = backgroundBillboard = undefined;
+    return;
+  }
+
+  backgroundBillboard.color = label._backgroundColor;
+  backgroundBillboard.show = label._show;
+  backgroundBillboard.position = label._position;
+  backgroundBillboard.eyeOffset = label._eyeOffset;
+  backgroundBillboard.pixelOffset = label._pixelOffset;
+  backgroundBillboard.horizontalOrigin = HorizontalOrigin.LEFT;
+  backgroundBillboard.verticalOrigin = label._verticalOrigin;
+  backgroundBillboard.heightReference = label._heightReference;
+  backgroundBillboard.scale = label.totalScale;
+  backgroundBillboard.pickPrimitive = label;
+  backgroundBillboard.id = label._id;
+  backgroundBillboard.translucencyByDistance = label._translucencyByDistance;
+  backgroundBillboard.pixelOffsetScaleByDistance =
+    label._pixelOffsetScaleByDistance;
+  backgroundBillboard.scaleByDistance = label._scaleByDistance;
+  backgroundBillboard.distanceDisplayCondition =
+    label._distanceDisplayCondition;
+  backgroundBillboard.disableDepthTestDistance =
+    label._disableDepthTestDistance;
+  backgroundBillboard.clusterShow = label.clusterShow;
+}
+
 function calculateWidthOffset(lineWidth, horizontalOrigin, backgroundPadding) {
   if (horizontalOrigin === HorizontalOrigin.CENTER) {
     return -lineWidth / 2;
@@ -507,7 +526,6 @@ function repositionAllGlyphs(label) {
       glyphPixelOffset.y = 0;
     }
     glyphPixelOffset.y = glyphPixelOffset.y * scale;
-
     backgroundBillboard.width = totalLineWidth;
     backgroundBillboard.height = totalLineHeight;
     backgroundBillboard._setTranslate(glyphPixelOffset);

package/Source/Scene/MetadataComponentType.js

@@ -119,12 +119,12 @@ MetadataComponentType.getMinimum = function (type) {
       return 0;
     case MetadataComponentType.INT64:
       if (FeatureDetection.supportsBigInt()) {
-        return BigInt("-9223372036854775808"); // eslint-disable-line
+        return BigInt("-9223372036854775808");
       }
       return -Math.pow(2, 63);
     case MetadataComponentType.UINT64:
       if (FeatureDetection.supportsBigInt()) {
-        return BigInt(0); // eslint-disable-line
+        return BigInt(0);
       }
       return 0;
     case MetadataComponentType.FLOAT32:
@@ -168,13 +168,13 @@ MetadataComponentType.getMaximum = function (type) {
     case MetadataComponentType.INT64:
       if (FeatureDetection.supportsBigInt()) {
         // Need to initialize with a string otherwise the value will be 9223372036854775808
-        return BigInt("9223372036854775807"); // eslint-disable-line
+        return BigInt("9223372036854775807");
       }
       return Math.pow(2, 63) - 1;
     case MetadataComponentType.UINT64:
       if (FeatureDetection.supportsBigInt()) {
         // Need to initialize with a string otherwise the value will be 18446744073709551616
-        return BigInt("18446744073709551615"); // eslint-disable-line
+        return BigInt("18446744073709551615");
       }
       return Math.pow(2, 64) - 1;
     case MetadataComponentType.FLOAT32:
@@ -333,7 +333,7 @@ MetadataComponentType.unnormalize = function (value, type) {
       type === MetadataComponentType.UINT64) &&
     FeatureDetection.supportsBigInt()
   ) {
-    value = BigInt(value); // eslint-disable-line
+    value = BigInt(value);
   }
 
   if (value > max) {

package/Source/Scene/MetadataTableProperty.js

@@ -549,7 +549,6 @@ function getInt64NumberFallback(index, values) {
 function getInt64BigIntFallback(index, values) {
   const dataView = values.dataView;
   const byteOffset = index * 8;
-  // eslint-disable-next-line no-undef
   let value = BigInt(0);
   const isNegative = (dataView.getUint8(byteOffset + 7) & 0x80) > 0;
   let carrying = true;
@@ -565,7 +564,7 @@ function getInt64BigIntFallback(index, values) {
         byte = ~byte & 0xff;
       }
     }
-    value += BigInt(byte) * (BigInt(1) << BigInt(i * 8)); // eslint-disable-line
+    value += BigInt(byte) * (BigInt(1) << BigInt(i * 8));
   }
   if (isNegative) {
     value = -value;
@@ -592,14 +591,11 @@ function getUint64BigIntFallback(index, values) {
   const byteOffset = index * 8;
 
   // Split 64-bit number into two 32-bit (4-byte) parts
-  // eslint-disable-next-line no-undef
   const left = BigInt(dataView.getUint32(byteOffset, true));
 
-  // eslint-disable-next-line no-undef
   const right = BigInt(dataView.getUint32(byteOffset + 4, true));
 
   // Combine the two 32-bit values
-  // eslint-disable-next-line no-undef
   const value = left + BigInt(4294967296) * right;
 
   return value;
@@ -770,7 +766,6 @@ function BufferView(bufferView, componentType, length) {
         return getInt64BigIntFallback(index, that);
       };
     } else {
-      // eslint-disable-next-line
       typedArray = new BigInt64Array(
         bufferView.buffer,
         bufferView.byteOffset,
@@ -778,7 +773,7 @@ function BufferView(bufferView, componentType, length) {
       );
       setFunction = function (index, value) {
         // Convert the number to a BigInt before setting the value in the typed array
-        that.typedArray[index] = BigInt(value); // eslint-disable-line
+        that.typedArray[index] = BigInt(value);
       };
     }
   } else if (componentType === MetadataComponentType.UINT64) {
@@ -804,7 +799,6 @@ function BufferView(bufferView, componentType, length) {
         return getUint64BigIntFallback(index, that);
       };
     } else {
-      // eslint-disable-next-line
       typedArray = new BigUint64Array(
         bufferView.buffer,
         bufferView.byteOffset,
@@ -812,7 +806,7 @@ function BufferView(bufferView, componentType, length) {
       );
       setFunction = function (index, value) {
         // Convert the number to a BigInt before setting the value in the typed array
-        that.typedArray[index] = BigInt(value); // eslint-disable-line
+        that.typedArray[index] = BigInt(value);
       };
     }
   } else {

package/Source/Scene/Model/EdgeDetectionPipelineStage.js

@@ -0,0 +1,42 @@
+import EdgeDetectionStageFS from "../../Shaders/Model/EdgeDetectionStageFS.js";
+
+/**
+ * Performs the screen-space edge visibility / composition pass. This stage does not
+ * build edge geometry itself; that work is handled earlier by {@link EdgeVisibilityPipelineStage},
+ * which extracts unique model edges and writes them during a dedicated edge render pass
+ * into edge ID / color targets. The fragment logic added here then:
+ * <ul>
+ *  <li>Samples the edge render targets (edge color + per-edge feature ID)</li>
+ *  <li>Compares per-edge feature IDs with underlying surface feature IDs to suppress
+ *      edges that belong to filtered or hidden features</li>
+ *  <li>Performs depth-based tests (e.g., against globe or scene depth) to discard
+ *      occluded edges</li>
+ * </ul>
+ * In summary: EdgeVisibilityPipelineStage = generate & encode edges; this stage = decide which of
+ * those encoded edges are actually visible in the final frame and composite them.
+ *
+ * @namespace EdgeDetectionPipelineStage
+ * @private
+ */
+const EdgeDetectionPipelineStage = {
+  name: "EdgeDetectionPipelineStage",
+};
+
+/**
+ * Process a primitive by injecting the fragment shader logic that consumes the
+ * intermediate edge buffers produced by the edge geometry pass. It adds code to:
+ * <ul>
+ *  <li>Read edge color / edge ID MRT outputs</li>
+ *  <li>Apply depth & feature ID based rejection</li>
+ *  <li>Emit final edge color for composition</li>
+ * </ul>
+ * @param {PrimitiveRenderResources} renderResources The render resources for the primitive
+ * @private
+ */
+EdgeDetectionPipelineStage.process = function (renderResources) {
+  const shaderBuilder = renderResources.shaderBuilder;
+
+  shaderBuilder.addFragmentLines([EdgeDetectionStageFS]);
+};
+
+export default EdgeDetectionPipelineStage;