@cesium/engine 6.2.0 → 8.0.0

package/Source/DataSources/ModelVisualizer.js

@@ -4,19 +4,22 @@ import Cartesian2 from "../Core/Cartesian2.js";
 import Cartesian3 from "../Core/Cartesian3.js";
 import Check from "../Core/Check.js";
 import Color from "../Core/Color.js";
+import defaultValue from "../Core/defaultValue.js";
 import defined from "../Core/defined.js";
 import destroyObject from "../Core/destroyObject.js";
 import DeveloperError from "../Core/DeveloperError.js";
+import Ellipsoid from "../Core/Ellipsoid.js";
 import Matrix4 from "../Core/Matrix4.js";
 import Resource from "../Core/Resource.js";
 import ColorBlendMode from "../Scene/ColorBlendMode.js";
-import HeightReference from "../Scene/HeightReference.js";
+import HeightReference, {
+  isHeightReferenceClamp,
+} from "../Scene/HeightReference.js";
 import Model from "../Scene/Model/Model.js";
 import ModelAnimationLoop from "../Scene/ModelAnimationLoop.js";
 import ShadowMode from "../Scene/ShadowMode.js";
 import BoundingSphereState from "./BoundingSphereState.js";
 import Property from "./Property.js";
-import sampleTerrainMostDetailed from "../Core/sampleTerrainMostDetailed.js";
 import Cartographic from "../Core/Cartographic.js";
 
 const defaultScale = 1.0;
@@ -172,9 +175,6 @@ ModelVisualizer.prototype.update = function (time) {
         articulationsScratch: {},
         loadFailed: false,
         modelUpdated: false,
-        awaitingSampleTerrain: false,
-        clampedBoundingSphere: undefined,
-        sampleTerrainFailed: false,
       };
       modelHash[entity.id] = modelData;
 
@@ -399,9 +399,6 @@ ModelVisualizer.prototype.destroy = function () {
   return destroyObject(this);
 };
 
-// Used for testing.
-ModelVisualizer._sampleTerrainMostDetailed = sampleTerrainMostDetailed;
-
 const scratchPosition = new Cartesian3();
 const scratchCartographic = new Cartographic();
 /**
@@ -445,106 +442,30 @@ ModelVisualizer.prototype.getBoundingSphere = function (entity, result) {
 
   const scene = this._scene;
   const globe = scene.globe;
+  const ellipsoid = defaultValue(globe?.ellipsoid, Ellipsoid.WGS84);
 
-  // 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 (defined(globe) && hasHeightReference) {
-    const ellipsoid = globe.ellipsoid;
+  if (hasHeightReference) {
     const modelMatrix = model.modelMatrix;
     scratchPosition.x = modelMatrix[12];
     scratchPosition.y = modelMatrix[13];
     scratchPosition.z = modelMatrix[14];
-    const cartoPosition = ellipsoid.cartesianToCartographic(scratchPosition);
-
-    // For a terrain provider that does not have availability, like the EllipsoidTerrainProvider,
-    // we can directly assign the bounding sphere's center from model matrix's translation.
-    if (!defined(terrainProvider.availability)) {
-      // Regardless of what the original model's position is set to, for CLAMP_TO_GROUND, we reset it to 0
-      // when computing the position to zoom/fly to.
-      if (model.heightReference === HeightReference.CLAMP_TO_GROUND) {
-        cartoPosition.height = 0;
-      }
-
-      const scratchPosition = ellipsoid.cartographicToCartesian(cartoPosition);
-      BoundingSphere.clone(model.boundingSphere, result);
-      result.center = scratchPosition;
-
-      return BoundingSphereState.DONE;
-    }
-
-    // Otherwise, in the case of terrain providers with availability,
-    // since the model's bounding sphere may be clamped to a lower LOD tile if
-    // the camera is initially far away, we use sampleTerrainMostDetailed to estimate
-    // where the bounding sphere should be and set that as the target bounding sphere
-    // for the camera.
-    let clampedBoundingSphere = this._modelHash[entity.id]
-      .clampedBoundingSphere;
-
-    // Check if the sample terrain function has failed.
-    const sampleTerrainFailed = this._modelHash[entity.id].sampleTerrainFailed;
-    if (sampleTerrainFailed) {
-      this._modelHash[entity.id].sampleTerrainFailed = false;
-      return BoundingSphereState.FAILED;
-    }
+    const cartoPosition = ellipsoid.cartesianToCartographic(
+      scratchPosition,
+      scratchCartographic
+    );
 
-    if (!defined(clampedBoundingSphere)) {
-      clampedBoundingSphere = new BoundingSphere();
-
-      // Since this function is called per-frame, we set a flag when sampleTerrainMostDetailed
-      // is called and check for it to avoid calling it again.
-      const awaitingSampleTerrain = this._modelHash[entity.id]
-        .awaitingSampleTerrain;
-      if (!awaitingSampleTerrain) {
-        Cartographic.clone(cartoPosition, scratchCartographic);
-        this._modelHash[entity.id].awaitingSampleTerrain = true;
-        ModelVisualizer._sampleTerrainMostDetailed(terrainProvider, [
-          scratchCartographic,
-        ])
-          .then((result) => {
-            if (this.isDestroyed()) {
-              return;
-            }
-
-            this._modelHash[entity.id].awaitingSampleTerrain = false;
-
-            const updatedCartographic = result[0];
-            if (model.heightReference === HeightReference.RELATIVE_TO_GROUND) {
-              updatedCartographic.height += cartoPosition.height;
-            }
-            ellipsoid.cartographicToCartesian(
-              updatedCartographic,
-              scratchPosition
-            );
-
-            // Update the bounding sphere with the updated position.
-            BoundingSphere.clone(model.boundingSphere, clampedBoundingSphere);
-            clampedBoundingSphere.center = scratchPosition;
-
-            this._modelHash[
-              entity.id
-            ].clampedBoundingSphere = BoundingSphere.clone(
-              clampedBoundingSphere
-            );
-          })
-          .catch((e) => {
-            if (this.isDestroyed()) {
-              return;
-            }
-
-            this._modelHash[entity.id].sampleTerrainFailed = true;
-            this._modelHash[entity.id].awaitingSampleTerrain = false;
-          });
+    const height = scene.getHeight(cartoPosition, model.heightReference);
+    if (defined(height)) {
+      if (isHeightReferenceClamp(model.heightReference)) {
+        cartoPosition.height = height;
+      } else {
+        cartoPosition.height += height;
       }
-
-      // We will return the state as pending until the clamped bounding sphere is defined,
-      // which happens when the sampleTerrainMostDetailed promise returns.
-      return BoundingSphereState.PENDING;
     }
 
-    BoundingSphere.clone(clampedBoundingSphere, result);
-    // Reset the clamped bounding sphere.
-    this._modelHash[entity.id].clampedBoundingSphere = undefined;
+    BoundingSphere.clone(model.boundingSphere, result);
+    result.center = ellipsoid.cartographicToCartesian(cartoPosition);
     return BoundingSphereState.DONE;
   }
 

package/Source/DataSources/PolygonGeometryUpdater.js

@@ -418,8 +418,14 @@ PolygonGeometryUpdater.prototype._setStaticOptions = function (
     extrudedHeightReferenceValue
   );
   if (extrudedHeightValue === GroundGeometryUpdater.CLAMP_TO_GROUND) {
+    const rectangle = PolygonGeometry.computeRectangleFromPositions(
+      options.polygonHierarchy.positions,
+      options.ellipsoid,
+      options.arcType,
+      scratchRectangle
+    );
     extrudedHeightValue = ApproximateTerrainHeights.getMinimumMaximumHeights(
-      PolygonGeometry.computeRectangle(options, scratchRectangle)
+      rectangle
     ).minimumTerrainHeight;
   }
 
@@ -565,8 +571,14 @@ DyanmicPolygonGeometryUpdater.prototype._setOptions = function (
     extrudedHeightReferenceValue
   );
   if (extrudedHeightValue === GroundGeometryUpdater.CLAMP_TO_GROUND) {
+    const rectangle = PolygonGeometry.computeRectangleFromPositions(
+      options.polygonHierarchy.positions,
+      options.ellipsoid,
+      options.arcType,
+      scratchRectangle
+    );
     extrudedHeightValue = ApproximateTerrainHeights.getMinimumMaximumHeights(
-      PolygonGeometry.computeRectangle(options, scratchRectangle)
+      rectangle
     ).minimumTerrainHeight;
   }
 

package/Source/DataSources/PolylineGeometryUpdater.js

@@ -249,8 +249,7 @@ Object.defineProperties(PolylineGeometryUpdater.prototype, {
   },
   /**
    * Gets a value indicating if the geometry is time-varying.
-   * If true, all visualization is delegated to the {@link DynamicGeometryUpdater}
-   * returned by GeometryUpdater#createDynamicUpdater.
+   *
    * @memberof PolylineGeometryUpdater.prototype
    *
    * @type {boolean}
@@ -661,12 +660,13 @@ function getLine(dynamicGeometryUpdater) {
     return dynamicGeometryUpdater._line;
   }
 
-  const sceneId = dynamicGeometryUpdater._geometryUpdater._scene.id;
-  let polylineCollection = polylineCollections[sceneId];
   const primitives = dynamicGeometryUpdater._primitives;
+  const polylineCollectionId =
+    dynamicGeometryUpdater._geometryUpdater._scene.id + primitives._guid;
+  let polylineCollection = polylineCollections[polylineCollectionId];
   if (!defined(polylineCollection) || polylineCollection.isDestroyed()) {
     polylineCollection = new PolylineCollection();
-    polylineCollections[sceneId] = polylineCollection;
+    polylineCollections[polylineCollectionId] = polylineCollection;
     primitives.add(polylineCollection);
   } else if (!primitives.contains(polylineCollection)) {
     primitives.add(polylineCollection);
@@ -869,13 +869,14 @@ DynamicGeometryUpdater.prototype.isDestroyed = function () {
 
 DynamicGeometryUpdater.prototype.destroy = function () {
   const geometryUpdater = this._geometryUpdater;
-  const sceneId = geometryUpdater._scene.id;
-  const polylineCollection = polylineCollections[sceneId];
+  const polylineCollectionId =
+    geometryUpdater._scene.id + this._primitives._guid;
+  const polylineCollection = polylineCollections[polylineCollectionId];
   if (defined(polylineCollection)) {
     polylineCollection.remove(this._line);
     if (polylineCollection.length === 0) {
       this._primitives.removeAndDestroy(polylineCollection);
-      delete polylineCollections[sceneId];
+      delete polylineCollections[polylineCollectionId];
     }
   }
   if (defined(this._groundPolylinePrimitive)) {

package/Source/DataSources/TerrainOffsetProperty.js

@@ -6,12 +6,12 @@ import destroyObject from "../Core/destroyObject.js";
 import Event from "../Core/Event.js";
 import Iso8601 from "../Core/Iso8601.js";
 import CesiumMath from "../Core/Math.js";
-import HeightReference from "../Scene/HeightReference.js";
-import SceneMode from "../Scene/SceneMode.js";
+import HeightReference, {
+  isHeightReferenceRelative,
+} from "../Scene/HeightReference.js";
 import Property from "./Property.js";
 
 const scratchPosition = new Cartesian3();
-const scratchCarto = new Cartographic();
 
 /**
  * @private
@@ -118,40 +118,32 @@ TerrainOffsetProperty.prototype._updateClamping = function () {
   const globe = scene.globe;
   const position = this._position;
 
-  if (!defined(globe) || Cartesian3.equals(position, Cartesian3.ZERO)) {
+  if (Cartesian3.equals(position, Cartesian3.ZERO)) {
     this._terrainHeight = 0;
     return;
   }
   const ellipsoid = globe.ellipsoid;
-  const surface = globe._surface;
-
-  const that = this;
   const cartographicPosition = ellipsoid.cartesianToCartographic(
     position,
     this._cartographicPosition
   );
-  const height = globe.getHeight(cartographicPosition);
+
+  const height = scene.getHeight(cartographicPosition, this._heightReference);
   if (defined(height)) {
     this._terrainHeight = height;
   } else {
     this._terrainHeight = 0;
   }
 
-  function updateFunction(clampedPosition) {
-    if (scene.mode === SceneMode.SCENE3D) {
-      const carto = ellipsoid.cartesianToCartographic(
-        clampedPosition,
-        scratchCarto
-      );
-      that._terrainHeight = carto.height;
-    } else {
-      that._terrainHeight = clampedPosition.x;
-    }
-    that.definitionChanged.raiseEvent();
-  }
-  this._removeCallbackFunc = surface.updateHeight(
+  const updateFunction = (clampedPosition) => {
+    this._terrainHeight = clampedPosition.height;
+    this.definitionChanged.raiseEvent();
+  };
+
+  this._removeCallbackFunc = scene.updateHeight(
     cartographicPosition,
-    updateFunction
+    updateFunction,
+    this._heightReference
   );
 };
 
@@ -174,7 +166,7 @@ TerrainOffsetProperty.prototype.getValue = function (time, result) {
 
   if (
     heightReference === HeightReference.NONE &&
-    extrudedHeightReference !== HeightReference.RELATIVE_TO_GROUND
+    !isHeightReferenceRelative(extrudedHeightReference)
   ) {
     this._position = Cartesian3.clone(Cartesian3.ZERO, this._position);
     return Cartesian3.clone(Cartesian3.ZERO, result);

package/Source/Renderer/AutomaticUniforms.js

@@ -954,7 +954,8 @@ const AutomaticUniforms = {
 
   /**
    * An automatic GLSL uniform containing the ellipsoid radii of curvature at the camera position.
-   * The .x component is the prime vertical radius, .y is the meridional.
+   * The .x component is the prime vertical radius of curvature (east-west direction)
+   * .y is the meridional radius of curvature (north-south direction)
    * This uniform is only valid when the {@link SceneMode} is <code>SCENE3D</code>.
    */
   czm_eyeEllipsoidCurvature: new AutomaticUniform({
@@ -1591,6 +1592,125 @@ const AutomaticUniforms = {
     },
   }),
 
+  /**
+   * An automatic GLSL uniform scalar used to set a minimum brightness when dynamic lighting is applied to fog.
+   *
+   * @see czm_fog
+   */
+  czm_fogMinimumBrightness: new AutomaticUniform({
+    size: 1,
+    datatype: WebGLConstants.FLOAT,
+    getValue: function (uniformState) {
+      return uniformState.fogMinimumBrightness;
+    },
+  }),
+
+  /**
+   * An automatic uniform representing the color shift for the atmosphere in HSB color space
+   *
+   * @example
+   * uniform vec3 czm_atmosphereHsbShift;
+   */
+  czm_atmosphereHsbShift: new AutomaticUniform({
+    size: 1,
+    datatype: WebGLConstants.FLOAT_VEC3,
+    getValue: function (uniformState) {
+      return uniformState.atmosphereHsbShift;
+    },
+  }),
+  /**
+   * An automatic uniform representing the intensity of the light that is used for computing the atmosphere color
+   *
+   * @example
+   * uniform float czm_atmosphereLightIntensity;
+   */
+  czm_atmosphereLightIntensity: new AutomaticUniform({
+    size: 1,
+    datatype: WebGLConstants.FLOAT,
+    getValue: function (uniformState) {
+      return uniformState.atmosphereLightIntensity;
+    },
+  }),
+  /**
+   * An automatic uniform representing the Rayleigh scattering coefficient used when computing the atmosphere scattering
+   *
+   * @example
+   * uniform vec3 czm_atmosphereRayleighCoefficient;
+   */
+  czm_atmosphereRayleighCoefficient: new AutomaticUniform({
+    size: 1,
+    datatype: WebGLConstants.FLOAT_VEC3,
+    getValue: function (uniformState) {
+      return uniformState.atmosphereRayleighCoefficient;
+    },
+  }),
+  /**
+   * An automatic uniform representing the Rayleigh scale height in meters used for computing atmosphere scattering.
+   *
+   * @example
+   * uniform vec3 czm_atmosphereRayleighScaleHeight;
+   */
+  czm_atmosphereRayleighScaleHeight: new AutomaticUniform({
+    size: 1,
+    datatype: WebGLConstants.FLOAT,
+    getValue: function (uniformState) {
+      return uniformState.atmosphereRayleighScaleHeight;
+    },
+  }),
+  /**
+   * An automatic uniform representing the Mie scattering coefficient used when computing atmosphere scattering.
+   *
+   * @example
+   * uniform vec3 czm_atmosphereMieCoefficient;
+   */
+  czm_atmosphereMieCoefficient: new AutomaticUniform({
+    size: 1,
+    datatype: WebGLConstants.FLOAT_VEC3,
+    getValue: function (uniformState) {
+      return uniformState.atmosphereMieCoefficient;
+    },
+  }),
+  /**
+   * An automatic uniform storign the Mie scale height used when computing atmosphere scattering.
+   *
+   * @example
+   * uniform float czm_atmosphereMieScaleHeight;
+   */
+  czm_atmosphereMieScaleHeight: new AutomaticUniform({
+    size: 1,
+    datatype: WebGLConstants.FLOAT,
+    getValue: function (uniformState) {
+      return uniformState.atmosphereMieScaleHeight;
+    },
+  }),
+  /**
+   * An automatic uniform representing the anisotropy of the medium to consider for Mie scattering.
+   *
+   * @example
+   * uniform float czm_atmosphereAnisotropy;
+   */
+  czm_atmosphereMieAnisotropy: new AutomaticUniform({
+    size: 1,
+    datatype: WebGLConstants.FLOAT,
+    getValue: function (uniformState) {
+      return uniformState.atmosphereMieAnisotropy;
+    },
+  }),
+
+  /**
+   * An automatic uniform representing which light source to use for dynamic lighting
+   *
+   * @example
+   * uniform float czm_atmosphereDynamicLighting
+   */
+  czm_atmosphereDynamicLighting: new AutomaticUniform({
+    size: 1,
+    datatype: WebGLConstants.FLOAT,
+    getValue: function (uniformState) {
+      return uniformState.atmosphereDynamicLighting;
+    },
+  }),
+
   /**
    * An automatic GLSL uniform representing the splitter position to use when rendering with a splitter.
    * This will be in pixel coordinates relative to the canvas.

package/Source/Renderer/Context.js

@@ -1432,6 +1432,16 @@ Context.prototype.endFrame = function () {
   }
 };
 
+/**
+ * @private
+ * @param {object} readState An object with the following properties:
+ * @param {number} [readState.x=0] The x offset of the rectangle to read from.
+ * @param {number} [readState.y=0] The y offset of the rectangle to read from.
+ * @param {number} [readState.width=gl.drawingBufferWidth] The width of the rectangle to read from.
+ * @param {number} [readState.height=gl.drawingBufferHeight] The height of the rectangle to read from.
+ * @param {Framebuffer} [readState.framebuffer] The framebuffer to read from. If undefined, the read will be from the default framebuffer.
+ * @returns {Uint8Array|Uint16Array|Float32Array|Uint32Array} The pixels in the specified rectangle.
+ */
 Context.prototype.readPixels = function (readState) {
   const gl = this._gl;
 

package/Source/Renderer/ContextLimits.js

@@ -1,4 +1,6 @@
 /**
+ * These are set in the constructor for {@link Context}
+ *
  * @private
  */
 const ContextLimits = {

package/Source/Renderer/UniformState.js

@@ -161,6 +161,16 @@ function UniformState() {
   this._specularEnvironmentMapsMaximumLOD = undefined;
 
   this._fogDensity = undefined;
+  this._fogMinimumBrightness = undefined;
+
+  this._atmosphereHsbShift = undefined;
+  this._atmosphereLightIntensity = undefined;
+  this._atmosphereRayleighCoefficient = new Cartesian3();
+  this._atmosphereRayleighScaleHeight = new Cartesian3();
+  this._atmosphereMieCoefficient = new Cartesian3();
+  this._atmosphereMieScaleHeight = undefined;
+  this._atmosphereMieAnisotropy = undefined;
+  this._atmosphereDynamicLighting = undefined;
 
   this._invertClassificationColor = undefined;
 
@@ -915,6 +925,99 @@ Object.defineProperties(UniformState.prototype, {
     },
   },
 
+  /**
+   * A scalar used as a minimum value when brightening fog
+   * @memberof UniformState.prototype
+   * @type {number}
+   */
+  fogMinimumBrightness: {
+    get: function () {
+      return this._fogMinimumBrightness;
+    },
+  },
+
+  /**
+   * A color shift to apply to the atmosphere color in HSB.
+   * @memberof UniformState.prototype
+   * @type {Cartesian3}
+   */
+  atmosphereHsbShift: {
+    get: function () {
+      return this._atmosphereHsbShift;
+    },
+  },
+  /**
+   * The intensity of the light that is used for computing the atmosphere color
+   * @memberof UniformState.prototype
+   * @type {number}
+   */
+  atmosphereLightIntensity: {
+    get: function () {
+      return this._atmosphereLightIntensity;
+    },
+  },
+  /**
+   * The Rayleigh scattering coefficient used in the atmospheric scattering equations for the sky atmosphere.
+   * @memberof UniformState.prototype
+   * @type {Cartesian3}
+   */
+  atmosphereRayleighCoefficient: {
+    get: function () {
+      return this._atmosphereRayleighCoefficient;
+    },
+  },
+  /**
+   * The Rayleigh scale height used in the atmospheric scattering equations for the sky atmosphere, in meters.
+   * @memberof UniformState.prototype
+   * @type {number}
+   */
+  atmosphereRayleighScaleHeight: {
+    get: function () {
+      return this._atmosphereRayleighScaleHeight;
+    },
+  },
+  /**
+   * The Mie scattering coefficient used in the atmospheric scattering equations for the sky atmosphere.
+   * @memberof UniformState.prototype
+   * @type {Cartesian3}
+   */
+  atmosphereMieCoefficient: {
+    get: function () {
+      return this._atmosphereMieCoefficient;
+    },
+  },
+  /**
+   * The Mie scale height used in the atmospheric scattering equations for the sky atmosphere, in meters.
+   * @memberof UniformState.prototype
+   * @type {number}
+   */
+  atmosphereMieScaleHeight: {
+    get: function () {
+      return this._atmosphereMieScaleHeight;
+    },
+  },
+  /**
+   * The anisotropy of the medium to consider for Mie scattering.
+   * @memberof UniformState.prototype
+   * @type {number}
+   */
+  atmosphereMieAnisotropy: {
+    get: function () {
+      return this._atmosphereMieAnisotropy;
+    },
+  },
+  /**
+   * Which light source to use for dynamically lighting the atmosphere
+   *
+   * @memberof UniformState.prototype
+   * @type {DynamicAtmosphereLightingType}
+   */
+  atmosphereDynamicLighting: {
+    get: function () {
+      return this._atmosphereDynamicLighting;
+    },
+  },
+
   /**
    * A scalar that represents the geometric tolerance per meter
    * @memberof UniformState.prototype
@@ -1411,6 +1514,30 @@ UniformState.prototype.update = function (frameState) {
   }
 
   this._fogDensity = frameState.fog.density;
+  this._fogMinimumBrightness = frameState.fog.minimumBrightness;
+
+  const atmosphere = frameState.atmosphere;
+  if (defined(atmosphere)) {
+    this._atmosphereHsbShift = Cartesian3.fromElements(
+      atmosphere.hueShift,
+      atmosphere.saturationShift,
+      atmosphere.brightnessShift,
+      this._atmosphereHsbShift
+    );
+    this._atmosphereLightIntensity = atmosphere.lightIntensity;
+    this._atmosphereRayleighCoefficient = Cartesian3.clone(
+      atmosphere.rayleighCoefficient,
+      this._atmosphereRayleighCoefficient
+    );
+    this._atmosphereRayleighScaleHeight = atmosphere.rayleighScaleHeight;
+    this._atmosphereMieCoefficient = Cartesian3.clone(
+      atmosphere.mieCoefficient,
+      this._atmosphereMieCoefficient
+    );
+    this._atmosphereMieScaleHeight = atmosphere.mieScaleHeight;
+    this._atmosphereMieAnisotropy = atmosphere.mieAnisotropy;
+    this._atmosphereDynamicLighting = atmosphere.dynamicLighting;
+  }
 
   this._invertClassificationColor = frameState.invertClassificationColor;
 

package/Source/Renderer/demodernizeShader.js

@@ -26,7 +26,10 @@ function demodernizeShader(input, isFragmentShader) {
 
   if (isFragmentShader) {
     // Replace the in with varying.
-    output = output.replaceAll(/(in)\s+(vec\d|mat\d|float)/g, `varying $2`);
+    output = output.replaceAll(
+      /\n\s*(in)\s+(vec\d|mat\d|float)/g,
+      `\nvarying $2`
+    );
 
     if (/out_FragData_(\d+)/.test(output)) {
       output = `#extension GL_EXT_draw_buffers : enable\n${output}`;

package/Source/Scene/ArcGisMapService.js

@@ -4,7 +4,7 @@ import Resource from "../Core/Resource.js";
 
 let defaultTokenCredit;
 const defaultAccessToken =
-  "AAPK2b93071721df4cc78be0d8b3d79b1fd54YMocOcx2NxlbYTDkyO5gPk8XsDnguQgeMdFKepFwLwTgb8vHfPvSTdjy_KlMHlS";
+  "AAPKc6e43bbc520149f79229d173c04883558jat1YV8r6Xjl50ulCDeLTkHzW0vzUC-9m6ASQvGmPbo4-xY_kAzsJxJZm-j_Unr";
 /**
  * Default options for accessing the ArcGIS image tile service.
  *