@cesium/engine 10.0.0 → 11.0.0

package/Source/Renderer/UniformState.js

@@ -157,7 +157,6 @@ function UniformState() {
 
   this._sphericalHarmonicCoefficients = undefined;
   this._specularEnvironmentMaps = undefined;
-  this._specularEnvironmentMapsDimensions = new Cartesian2();
   this._specularEnvironmentMapsMaximumLOD = undefined;
 
   this._fogDensity = undefined;
@@ -1084,7 +1083,7 @@ Object.defineProperties(UniformState.prototype, {
   },
 
   /**
-   * The specular environment map atlas of the scene.
+   * The specular environment cube map of the scene.
    * @memberof UniformState.prototype
    * @type {Texture}
    */
@@ -1095,18 +1094,7 @@ Object.defineProperties(UniformState.prototype, {
   },
 
   /**
-   * The dimensions of the specular environment map atlas of the scene.
-   * @memberof UniformState.prototype
-   * @type {Cartesian2}
-   */
-  specularEnvironmentMapsDimensions: {
-    get: function () {
-      return this._specularEnvironmentMapsDimensions;
-    },
-  },
-
-  /**
-   * The maximum level-of-detail of the specular environment map atlas of the scene.
+   * The maximum level-of-detail of the specular environment cube map of the scene.
    * @memberof UniformState.prototype
    * @type {number}
    */
@@ -1305,19 +1293,13 @@ function setCamera(uniformState, camera) {
   );
 }
 
-let transformMatrix = new Matrix3();
+const transformMatrix = new Matrix3();
 const sunCartographicScratch = new Cartographic();
 function setSunAndMoonDirections(uniformState, frameState) {
-  if (
-    !defined(
-      Transforms.computeIcrfToFixedMatrix(frameState.time, transformMatrix)
-    )
-  ) {
-    transformMatrix = Transforms.computeTemeToPseudoFixedMatrix(
-      frameState.time,
-      transformMatrix
-    );
-  }
+  Transforms.computeIcrfToCentralBodyFixedMatrix(
+    frameState.time,
+    transformMatrix
+  );
 
   let position = Simon1994PlanetaryPositions.computeSunPositionInEarthInertialFrame(
     frameState.time,
@@ -1497,7 +1479,7 @@ UniformState.prototype.update = function (frameState) {
   );
 
   // IE 11 doesn't optimize out uniforms that are #ifdef'd out. So undefined values for the spherical harmonic
-  // coefficients and specular environment map atlas dimensions cause a crash.
+  // coefficients cause a crash.
   this._sphericalHarmonicCoefficients = defaultValue(
     frameState.sphericalHarmonicCoefficients,
     EMPTY_ARRAY
@@ -1506,13 +1488,6 @@ UniformState.prototype.update = function (frameState) {
   this._specularEnvironmentMapsMaximumLOD =
     frameState.specularEnvironmentMapsMaximumLOD;
 
-  if (defined(this._specularEnvironmentMaps)) {
-    Cartesian2.clone(
-      this._specularEnvironmentMaps.dimensions,
-      this._specularEnvironmentMapsDimensions
-    );
-  }
-
   this._fogDensity = frameState.fog.density;
   this._fogMinimumBrightness = frameState.fog.minimumBrightness;
 

package/Source/Renderer/demodernizeShader.js

@@ -60,6 +60,8 @@ function demodernizeShader(input, isFragmentShader) {
       output = output.replaceAll(/gl_FragDepth/g, `gl_FragDepthEXT`);
     }
 
+    // Enable the EXT_shader_texture_lod extension
+    output = `#ifdef GL_EXT_shader_texture_lod\n#extension GL_EXT_shader_texture_lod : enable\n#endif\n${output}`;
     // Enable the OES_standard_derivatives extension
     output = `#ifdef GL_OES_standard_derivatives\n#extension GL_OES_standard_derivatives : enable\n#endif\n${output}`;
   } else {

package/Source/Renderer/loadCubeMap.js

@@ -41,17 +41,12 @@ import CubeMap from "./CubeMap.js";
 function loadCubeMap(context, urls, skipColorSpaceConversion) {
   //>>includeStart('debug', pragmas.debug);
   Check.defined("context", context);
+  Check.defined("urls", urls);
   if (
-    !defined(urls) ||
-    !defined(urls.positiveX) ||
-    !defined(urls.negativeX) ||
-    !defined(urls.positiveY) ||
-    !defined(urls.negativeY) ||
-    !defined(urls.positiveZ) ||
-    !defined(urls.negativeZ)
+    Object.values(CubeMap.FaceName).some((faceName) => !defined(urls[faceName]))
   ) {
     throw new DeveloperError(
-      "urls is required and must have positiveX, negativeX, positiveY, negativeY, positiveZ, and negativeZ properties."
+      "urls must have positiveX, negativeX, positiveY, negativeY, positiveZ, and negativeZ properties."
     );
   }
   //>>includeEnd('debug');

package/Source/Scene/ArcGisMapService.js

@@ -4,7 +4,7 @@ import Resource from "../Core/Resource.js";
 
 let defaultTokenCredit;
 const defaultAccessToken =
-  "AAPTxy8BH1VEsoebNVZXo8HurEOF051kAEKlhkOhBEc9BmRcs5cw5x8CvIyg2oiotXJmY_GjoEUuuKAUvdWxusIx25kUy2AttkOs0FgosGzFJSsjafpWC40GiE5hiD0FLNSh3kxIW6w-5qqUQCEAwGY1t4yH7Fj-PjrkjPfSpw0_r2xF3lKLd0_LSmPWXCkYhqV1O67tWLNImHyr7SurJ92sA5YIG1pMJKEQU3Qv5k18p0g.AT1_sGbfSYDL";
+  "AAPTxy8BH1VEsoebNVZXo8HurEOF051kAEKlhkOhBEc9BmSXu8_pRnGhnW6yZLct-ukUzbJaZRAVfnmUrxDcAu_FaFDIC3M57EwfRm_DuTw9D5oHdLBTYIMD3tpUeFsNDjHHqar5fb1FGIN9KIV1Gk64dNBmhHhuOHY8cq2IhI0XFLj2qnAlqtKnM-lLsO6JpHuHPVD799V1o9VFm9vMW6a66vEi8-e--2QzKQecPYiaq98.AT1_p4pHwb3n";
 /**
  * Default options for accessing the ArcGIS image tile service.
  *

package/Source/Scene/Billboard.js

@@ -21,6 +21,7 @@ import HorizontalOrigin from "./HorizontalOrigin.js";
 import SceneMode from "./SceneMode.js";
 import SceneTransforms from "./SceneTransforms.js";
 import VerticalOrigin from "./VerticalOrigin.js";
+import SplitDirection from "./SplitDirection.js";
 
 /**
  * @typedef {object} Billboard.ConstructorOptions
@@ -49,6 +50,7 @@ import VerticalOrigin from "./VerticalOrigin.js";
  * @property {BoundingRectangle} [imageSubRegion] A {@link BoundingRectangle} Specifying the sub-region of the image to use for the billboard, rather than the entire image.
  * @property {DistanceDisplayCondition} [distanceDisplayCondition] A {@link DistanceDisplayCondition} Specifying the distance from the camera at which this billboard will be displayed.
  * @property {number} [disableDepthTestDistance] A number specifying the distance from the camera at which to disable the depth test to, for example, prevent clipping against terrain.
+ * @property {SplitDirection} [splitDirection] A {@link SplitDirection} Specifying the split property of the billboard.
  */
 
 /**
@@ -250,6 +252,11 @@ function Billboard(options, billboardCollection) {
   this._outlineWidth = defaultValue(options.outlineWidth, 0.0);
 
   this._updateClamping();
+
+  this._splitDirection = defaultValue(
+    options.splitDirection,
+    SplitDirection.NONE
+  );
 }
 
 const SHOW_INDEX = (Billboard.SHOW_INDEX = 0);
@@ -270,7 +277,8 @@ const DISTANCE_DISPLAY_CONDITION = (Billboard.DISTANCE_DISPLAY_CONDITION = 14);
 const DISABLE_DEPTH_DISTANCE = (Billboard.DISABLE_DEPTH_DISTANCE = 15);
 Billboard.TEXTURE_COORDINATE_BOUNDS = 16;
 const SDF_INDEX = (Billboard.SDF_INDEX = 17);
-Billboard.NUMBER_OF_PROPERTIES = 18;
+const SPLIT_DIRECTION_INDEX = (Billboard.SPLIT_DIRECTION_INDEX = 18);
+Billboard.NUMBER_OF_PROPERTIES = 19;
 
 function makeDirty(billboard, propertyChanged) {
   const billboardCollection = billboard._billboardCollection;
@@ -1072,6 +1080,24 @@ Object.defineProperties(Billboard.prototype, {
       }
     },
   },
+
+  /**
+   * Gets or sets the {@link SplitDirection} of this billboard.
+   * @memberof Billboard.prototype
+   * @type {SplitDirection}
+   * @default {@link SplitDirection.NONE}
+   */
+  splitDirection: {
+    get: function () {
+      return this._splitDirection;
+    },
+    set: function (value) {
+      if (this._splitDirection !== value) {
+        this._splitDirection = value;
+        makeDirty(this, SPLIT_DIRECTION_INDEX);
+      }
+    },
+  },
 });
 
 Billboard.prototype.getPickId = function (context) {
@@ -1567,7 +1593,8 @@ Billboard.prototype.equals = function (other) {
         this._distanceDisplayCondition,
         other._distanceDisplayCondition
       ) &&
-      this._disableDepthTestDistance === other._disableDepthTestDistance)
+      this._disableDepthTestDistance === other._disableDepthTestDistance &&
+      this._splitDirection === other._splitDirection)
   );
 };
 

package/Source/Scene/BillboardCollection.js

@@ -54,6 +54,7 @@ const DISTANCE_DISPLAY_CONDITION_INDEX = Billboard.DISTANCE_DISPLAY_CONDITION;
 const DISABLE_DEPTH_DISTANCE = Billboard.DISABLE_DEPTH_DISTANCE;
 const TEXTURE_COORDINATE_BOUNDS = Billboard.TEXTURE_COORDINATE_BOUNDS;
 const SDF_INDEX = Billboard.SDF_INDEX;
+const SPLIT_DIRECTION_INDEX = Billboard.SPLIT_DIRECTION_INDEX;
 const NUMBER_OF_PROPERTIES = Billboard.NUMBER_OF_PROPERTIES;
 
 let attributeLocations;
@@ -71,6 +72,7 @@ const attributeLocationsBatched = {
   textureCoordinateBoundsOrLabelTranslate: 9,
   a_batchId: 10,
   sdf: 11,
+  splitDirection: 12,
 };
 
 const attributeLocationsInstanced = {
@@ -87,6 +89,7 @@ const attributeLocationsInstanced = {
   textureCoordinateBoundsOrLabelTranslate: 10,
   a_batchId: 11,
   sdf: 12,
+  splitDirection: 13,
 };
 
 /**
@@ -311,6 +314,7 @@ function BillboardCollection(options) {
     BufferUsage.STATIC_DRAW, // PIXEL_OFFSET_SCALE_BY_DISTANCE_INDEX
     BufferUsage.STATIC_DRAW, // DISTANCE_DISPLAY_CONDITION_INDEX
     BufferUsage.STATIC_DRAW, // TEXTURE_COORDINATE_BOUNDS
+    BufferUsage.STATIC_DRAW, // SPLIT_DIRECTION_INDEX
   ];
 
   this._highlightColor = Color.clone(Color.WHITE); // Only used by Vector3DTilePoints
@@ -777,6 +781,12 @@ function createVAF(
       componentDatatype: ComponentDatatype.FLOAT,
       usage: buffersUsage[TEXTURE_COORDINATE_BOUNDS],
     },
+    {
+      index: attributeLocations.splitDirection,
+      componentsPerAttribute: 1,
+      componentDatatype: ComponentDatatype.FLOAT,
+      usage: buffersUsage[SPLIT_DIRECTION_INDEX],
+    },
   ];
 
   // Instancing requires one non-instanced attribute.
@@ -1586,6 +1596,34 @@ function writeSDF(
   }
 }
 
+function writeSplitDirection(
+  billboardCollection,
+  frameState,
+  textureAtlasCoordinates,
+  vafWriters,
+  billboard
+) {
+  const writer = vafWriters[attributeLocations.splitDirection];
+  let direction = 0.0;
+
+  const split = billboard.splitDirection;
+  if (defined(split)) {
+    direction = split;
+  }
+
+  let i;
+  if (billboardCollection._instanced) {
+    i = billboard._index;
+    writer(i, direction);
+  } else {
+    i = billboard._index * 4;
+    writer(i + 0, direction);
+    writer(i + 1, direction);
+    writer(i + 2, direction);
+    writer(i + 3, direction);
+  }
+}
+
 function writeBillboard(
   billboardCollection,
   frameState,
@@ -1670,6 +1708,13 @@ function writeBillboard(
     vafWriters,
     billboard
   );
+  writeSplitDirection(
+    billboardCollection,
+    frameState,
+    textureAtlasCoordinates,
+    vafWriters,
+    billboard
+  );
 }
 
 function recomputeActualPositions(
@@ -1981,6 +2026,10 @@ BillboardCollection.prototype.update = function (frameState) {
       writers.push(writeSDF);
     }
 
+    if (properties[SPLIT_DIRECTION_INDEX]) {
+      writers.push(writeSplitDirection);
+    }
+
     const numWriters = writers.length;
     vafWriters = this._vaf.writers;
 

package/Source/Scene/BingMapsImageryProvider.js

@@ -120,7 +120,16 @@ function metadataSuccess(data, imageryProviderBuilder) {
   imageryProviderBuilder.maximumLevel = resource.zoomMax - 1;
   imageryProviderBuilder.imageUrlSubdomains = resource.imageUrlSubdomains;
   imageryProviderBuilder.imageUrlTemplate = resource.imageUrl;
-  imageryProviderBuilder.attributionList = resource.imageryProviders;
+
+  let validProviders = resource.imageryProviders;
+  if (defined(resource.imageryProviders)) {
+    // prevent issues with the imagery API from crashing the viewer when the expected properties are not there
+    // See https://github.com/CesiumGS/cesium/issues/12088
+    validProviders = resource.imageryProviders.filter((provider) =>
+      provider.coverageAreas?.some((area) => defined(area.bbox))
+    );
+  }
+  imageryProviderBuilder.attributionList = validProviders;
 }
 
 function metadataFailure(metadataResource, error, provider) {

package/Source/Scene/CameraEventAggregator.js

@@ -9,7 +9,7 @@ import ScreenSpaceEventType from "../Core/ScreenSpaceEventType.js";
 import CameraEventType from "./CameraEventType.js";
 
 function getKey(type, modifier) {
-  let key = type;
+  let key = `${type}`;
   if (defined(modifier)) {
     key += `+${modifier}`;
   }
@@ -178,7 +178,6 @@ function listenMouseButtonDownUp(aggregator, modifier, type) {
   const isDown = aggregator._isDown;
   const eventStartPosition = aggregator._eventStartPosition;
   const pressTime = aggregator._pressTime;
-  const releaseTime = aggregator._releaseTime;
 
   isDown[key] = false;
   eventStartPosition[key] = new Cartesian2();
@@ -219,20 +218,64 @@ function listenMouseButtonDownUp(aggregator, modifier, type) {
 
   aggregator._eventHandler.setInputAction(
     function () {
-      aggregator._buttonsDown = Math.max(aggregator._buttonsDown - 1, 0);
-      isDown[key] = false;
-      releaseTime[key] = new Date();
+      cancelMouseDownAction(getKey(type, undefined), aggregator);
+      for (const modifier of Object.values(KeyboardEventModifier)) {
+        const cancelKey = getKey(type, modifier);
+        cancelMouseDownAction(cancelKey, aggregator);
+      }
     },
     up,
     modifier
   );
 }
 
+function cancelMouseDownAction(cancelKey, aggregator) {
+  const releaseTime = aggregator._releaseTime;
+  const isDown = aggregator._isDown;
+  if (isDown[cancelKey]) {
+    aggregator._buttonsDown = Math.max(aggregator._buttonsDown - 1, 0);
+  }
+  isDown[cancelKey] = false;
+  releaseTime[cancelKey] = new Date();
+}
+
 function cloneMouseMovement(mouseMovement, result) {
   Cartesian2.clone(mouseMovement.startPosition, result.startPosition);
   Cartesian2.clone(mouseMovement.endPosition, result.endPosition);
 }
 
+function refreshMouseDownStatus(type, modifier, aggregator) {
+  // first: Judge if the mouse is pressed
+  const isDown = aggregator._isDown;
+  let anyButtonIsDown = false;
+  const currentKey = getKey(type, modifier);
+  for (const [downKey, downValue] of Object.entries(isDown)) {
+    if (downKey.startsWith(type) && downValue && downKey !== currentKey) {
+      anyButtonIsDown = true;
+      cancelMouseDownAction(downKey, aggregator);
+    }
+  }
+
+  if (!anyButtonIsDown) {
+    return;
+  }
+
+  // second: If it is pressed, it will be transferred to the current modifier.
+  const pressTime = aggregator._pressTime;
+  let lastMovement = aggregator._lastMovement[currentKey];
+  if (!defined(lastMovement)) {
+    lastMovement = aggregator._lastMovement[currentKey] = {
+      startPosition: new Cartesian2(),
+      endPosition: new Cartesian2(),
+      valid: false,
+    };
+  }
+  aggregator._buttonsDown++;
+  lastMovement.valid = false;
+  isDown[currentKey] = true;
+  pressTime[currentKey] = new Date();
+}
+
 function listenMouseMove(aggregator, modifier) {
   const update = aggregator._update;
   const movement = aggregator._movement;
@@ -271,6 +314,7 @@ function listenMouseMove(aggregator, modifier) {
           const type = CameraEventType[typeName];
           if (defined(type)) {
             const key = getKey(type, modifier);
+            refreshMouseDownStatus(type, modifier, aggregator);
             if (isDown[key]) {
               if (!update[key]) {
                 Cartesian2.clone(

package/Source/Scene/Globe.js

@@ -979,7 +979,6 @@ Globe.prototype.beginFrame = function (frameState) {
   const tileProvider = surface.tileProvider;
   const terrainProvider = this.terrainProvider;
   const hasWaterMask =
-    this.showWaterEffect &&
     defined(terrainProvider) &&
     terrainProvider.hasWaterMask &&
     terrainProvider.hasWaterMask;
@@ -1034,6 +1033,7 @@ Globe.prototype.beginFrame = function (frameState) {
     tileProvider.zoomedOutOceanSpecularIntensity =
       mode === SceneMode.SCENE3D ? this._zoomedOutOceanSpecularIntensity : 0.0;
     tileProvider.hasWaterMask = hasWaterMask;
+    tileProvider.showWaterEffect = this.showWaterEffect;
     tileProvider.oceanNormalMap = this._oceanNormalMap;
     tileProvider.enableLighting = this.enableLighting;
     tileProvider.dynamicAtmosphereLighting = this.dynamicAtmosphereLighting;

package/Source/Scene/GlobeSurfaceShaderSet.js

@@ -109,6 +109,7 @@ GlobeSurfaceShaderSet.prototype.getShaderProgram = function (options) {
   const applyAlpha = options.applyAlpha;
   const applyDayNightAlpha = options.applyDayNightAlpha;
   const applySplit = options.applySplit;
+  const hasWaterMask = options.hasWaterMask;
   const showReflectiveOcean = options.showReflectiveOcean;
   const showOceanWaves = options.showOceanWaves;
   const enableLighting = options.enableLighting;
@@ -168,30 +169,31 @@ GlobeSurfaceShaderSet.prototype.getShaderProgram = function (options) {
     (applySaturation << 5) |
     (applyGamma << 6) |
     (applyAlpha << 7) |
-    (showReflectiveOcean << 8) |
-    (showOceanWaves << 9) |
-    (enableLighting << 10) |
-    (dynamicAtmosphereLighting << 11) |
-    (dynamicAtmosphereLightingFromSun << 12) |
-    (showGroundAtmosphere << 13) |
-    (perFragmentGroundAtmosphere << 14) |
-    (hasVertexNormals << 15) |
-    (useWebMercatorProjection << 16) |
-    (enableFog << 17) |
-    (quantization << 18) |
-    (applySplit << 19) |
-    (enableClippingPlanes << 20) |
-    (enableClippingPolygons << 21) |
-    (cartographicLimitRectangleFlag << 22) |
-    (imageryCutoutFlag << 23) |
-    (colorCorrect << 24) |
-    (highlightFillTile << 25) |
-    (colorToAlpha << 26) |
-    (hasGeodeticSurfaceNormals << 27) |
-    (hasExaggeration << 28) |
-    (showUndergroundColor << 29) |
-    (translucent << 30) |
-    (applyDayNightAlpha << 31);
+    (hasWaterMask << 8) |
+    (showReflectiveOcean << 9) |
+    (showOceanWaves << 10) |
+    (enableLighting << 11) |
+    (dynamicAtmosphereLighting << 12) |
+    (dynamicAtmosphereLightingFromSun << 13) |
+    (showGroundAtmosphere << 14) |
+    (perFragmentGroundAtmosphere << 15) |
+    (hasVertexNormals << 16) |
+    (useWebMercatorProjection << 17) |
+    (enableFog << 18) |
+    (quantization << 19) |
+    (applySplit << 20) |
+    (enableClippingPlanes << 21) |
+    (enableClippingPolygons << 22) |
+    (cartographicLimitRectangleFlag << 23) |
+    (imageryCutoutFlag << 24) |
+    (colorCorrect << 25) |
+    (highlightFillTile << 26) |
+    (colorToAlpha << 27) |
+    (hasGeodeticSurfaceNormals << 28) |
+    (hasExaggeration << 29) |
+    (showUndergroundColor << 30) |
+    (translucent << 31) |
+    (applyDayNightAlpha << 32);
 
   let currentClippingShaderState = 0;
   if (defined(clippingPlanes) && clippingPlanes.length > 0) {
@@ -279,6 +281,9 @@ GlobeSurfaceShaderSet.prototype.getShaderProgram = function (options) {
     if (applyDayNightAlpha) {
       fs.defines.push("APPLY_DAY_NIGHT_ALPHA");
     }
+    if (hasWaterMask) {
+      fs.defines.push("HAS_WATER_MASK");
+    }
     if (showReflectiveOcean) {
       fs.defines.push("SHOW_REFLECTIVE_OCEAN");
       vs.defines.push("SHOW_REFLECTIVE_OCEAN");

package/Source/Scene/GlobeSurfaceTileProvider.js

@@ -83,6 +83,7 @@ function GlobeSurfaceTileProvider(options) {
   this.lightingFadeOutDistance = 6500000.0;
   this.lightingFadeInDistance = 9000000.0;
   this.hasWaterMask = false;
+  this.showWaterEffect = false;
   this.oceanNormalMap = undefined;
   this.zoomedOutOceanSpecularIntensity = 0.5;
   this.enableLighting = false;
@@ -2181,8 +2182,8 @@ function addDrawCommandsForTile(tileProvider, tile, frameState) {
   const lambertDiffuseMultiplier = tileProvider.lambertDiffuseMultiplier;
   const vertexShadowDarkness = tileProvider.vertexShadowDarkness;
 
-  const showReflectiveOcean =
-    tileProvider.hasWaterMask && defined(waterMaskTexture);
+  const hasWaterMask = tileProvider.hasWaterMask && defined(waterMaskTexture);
+  const showReflectiveOcean = hasWaterMask && tileProvider.showWaterEffect;
   const oceanNormalMap = tileProvider.oceanNormalMap;
   const showOceanWaves = showReflectiveOcean && defined(oceanNormalMap);
   const terrainProvider = tileProvider.terrainProvider;
@@ -2214,7 +2215,7 @@ function addDrawCommandsForTile(tileProvider, tile, frameState) {
     perFragmentGroundAtmosphere = cameraDistance > fadeOutDistance;
   }
 
-  if (showReflectiveOcean) {
+  if (hasWaterMask) {
     --maxTextures;
   }
   if (showOceanWaves) {
@@ -2329,6 +2330,7 @@ function addDrawCommandsForTile(tileProvider, tile, frameState) {
   const surfaceShaderSetOptions = surfaceShaderSetOptionsScratch;
   surfaceShaderSetOptions.frameState = frameState;
   surfaceShaderSetOptions.surfaceTile = surfaceTile;
+  surfaceShaderSetOptions.hasWaterMask = hasWaterMask;
   surfaceShaderSetOptions.showReflectiveOcean = showReflectiveOcean;
   surfaceShaderSetOptions.showOceanWaves = showOceanWaves;
   surfaceShaderSetOptions.enableLighting = tileProvider.enableLighting;