@cesium/engine 6.1.1 → 7.0.0

package/Source/Renderer/AutomaticUniforms.js

@@ -939,6 +939,60 @@ const AutomaticUniforms = {
     },
   }),
 
+  /**
+   * An automatic GLSL uniform containing the ellipsoid surface normal
+   * at the position below the eye (camera), in eye coordinates.
+   * This uniform is only valid when the {@link SceneMode} is <code>SCENE3D</code>.
+   */
+  czm_eyeEllipsoidNormalEC: new AutomaticUniform({
+    size: 1,
+    datatype: WebGLConstants.FLOAT_VEC3,
+    getValue: function (uniformState) {
+      return uniformState.eyeEllipsoidNormalEC;
+    },
+  }),
+
+  /**
+   * An automatic GLSL uniform containing the ellipsoid radii of curvature at the camera position.
+   * 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({
+    size: 1,
+    datatype: WebGLConstants.FLOAT_VEC2,
+    getValue: function (uniformState) {
+      return uniformState.eyeEllipsoidCurvature;
+    },
+  }),
+
+  /**
+   * An automatic GLSL uniform containing the transform from model coordinates
+   * to an east-north-up coordinate system centered at the position on the
+   * ellipsoid below the camera.
+   * This uniform is only valid when the {@link SceneMode} is <code>SCENE3D</code>.
+   */
+  czm_modelToEnu: new AutomaticUniform({
+    size: 1,
+    datatype: WebGLConstants.FLOAT_MAT4,
+    getValue: function (uniformState) {
+      return uniformState.modelToEnu;
+    },
+  }),
+
+  /**
+   * An automatic GLSL uniform containing the the inverse of
+   * {@link AutomaticUniforms.czm_modelToEnu}.
+   * This uniform is only valid when the {@link SceneMode} is <code>SCENE3D</code>.
+   */
+  czm_enuToModel: new AutomaticUniform({
+    size: 1,
+    datatype: WebGLConstants.FLOAT_MAT4,
+    getValue: function (uniformState) {
+      return uniformState.enuToModel;
+    },
+  }),
+
   /**
    * An automatic GLSL uniform containing the near distance (<code>x</code>) and the far distance (<code>y</code>)
    * of the frustum defined by the camera.  This is the largest possible frustum, not an individual
@@ -1538,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/UniformState.js

@@ -144,6 +144,10 @@ function UniformState() {
   this._frustum2DWidth = 0.0;
   this._eyeHeight = 0.0;
   this._eyeHeight2D = new Cartesian2();
+  this._eyeEllipsoidNormalEC = new Cartesian3();
+  this._eyeEllipsoidCurvature = new Cartesian2();
+  this._modelToEnu = new Matrix4();
+  this._enuToModel = new Matrix4();
   this._pixelRatio = 1.0;
   this._orthographicIn3D = false;
   this._backgroundColor = new Color();
@@ -157,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;
 
@@ -696,6 +710,52 @@ Object.defineProperties(UniformState.prototype, {
     },
   },
 
+  /**
+   * The ellipsoid surface normal at the camera position, in model coordinates.
+   * @memberof UniformState.prototype
+   * @type {Cartesian3}
+   */
+  eyeEllipsoidNormalEC: {
+    get: function () {
+      return this._eyeEllipsoidNormalEC;
+    },
+  },
+
+  /**
+   * The ellipsoid radii of curvature at the camera position.
+   * The .x component is the prime vertical radius, .y is the meridional.
+   * @memberof UniformState.prototype
+   * @type {Cartesian2}
+   */
+  eyeEllipsoidCurvature: {
+    get: function () {
+      return this._eyeEllipsoidCurvature;
+    },
+  },
+
+  /**
+   * A transform from model coordinates to an east-north-up coordinate system
+   * centered at the position on the ellipsoid below the camera
+   * @memberof UniformState.prototype
+   * @type {Matrix4}
+   */
+  modelToEnu: {
+    get: function () {
+      return this._modelToEnu;
+    },
+  },
+
+  /**
+   * The inverse of {@link UniformState.prototype.modelToEnu}
+   * @memberof UniformState.prototype
+   * @type {Matrix4}
+   */
+  enuToModel: {
+    get: function () {
+      return this._enuToModel;
+    },
+  },
+
   /**
    * The sun position in 3D world coordinates at the current scene time.
    * @memberof UniformState.prototype
@@ -865,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
@@ -1068,20 +1221,88 @@ function setInfiniteProjection(uniformState, matrix) {
   uniformState._modelViewInfiniteProjectionDirty = true;
 }
 
+const surfacePositionScratch = new Cartesian3();
+const enuTransformScratch = new Matrix4();
+
 function setCamera(uniformState, camera) {
   Cartesian3.clone(camera.positionWC, uniformState._cameraPosition);
   Cartesian3.clone(camera.directionWC, uniformState._cameraDirection);
   Cartesian3.clone(camera.rightWC, uniformState._cameraRight);
   Cartesian3.clone(camera.upWC, uniformState._cameraUp);
 
+  const ellipsoid = uniformState._ellipsoid;
+  let surfacePosition;
+
   const positionCartographic = camera.positionCartographic;
   if (!defined(positionCartographic)) {
-    uniformState._eyeHeight = -uniformState._ellipsoid.maximumRadius;
+    uniformState._eyeHeight = -ellipsoid.maximumRadius;
+    if (Cartesian3.magnitude(camera.positionWC) > 0.0) {
+      uniformState._eyeEllipsoidNormalEC = Cartesian3.normalize(
+        camera.positionWC,
+        uniformState._eyeEllipsoidNormalEC
+      );
+    }
+    surfacePosition = ellipsoid.scaleToGeodeticSurface(
+      camera.positionWC,
+      surfacePositionScratch
+    );
   } else {
     uniformState._eyeHeight = positionCartographic.height;
+    uniformState._eyeEllipsoidNormalEC = ellipsoid.geodeticSurfaceNormalCartographic(
+      positionCartographic,
+      uniformState._eyeEllipsoidNormalEC
+    );
+    surfacePosition = Cartesian3.fromRadians(
+      positionCartographic.longitude,
+      positionCartographic.latitude,
+      0.0,
+      ellipsoid,
+      surfacePositionScratch
+    );
   }
 
   uniformState._encodedCameraPositionMCDirty = true;
+
+  if (!defined(surfacePosition)) {
+    return;
+  }
+
+  uniformState._eyeEllipsoidNormalEC = Matrix3.multiplyByVector(
+    uniformState._viewRotation,
+    uniformState._eyeEllipsoidNormalEC,
+    uniformState._eyeEllipsoidNormalEC
+  );
+
+  const enuToWorld = Transforms.eastNorthUpToFixedFrame(
+    surfacePosition,
+    ellipsoid,
+    enuTransformScratch
+  );
+  uniformState._enuToModel = Matrix4.multiplyTransformation(
+    uniformState.inverseModel,
+    enuToWorld,
+    uniformState._enuToModel
+  );
+  uniformState._modelToEnu = Matrix4.inverseTransformation(
+    uniformState._enuToModel,
+    uniformState._modelToEnu
+  );
+
+  if (
+    !CesiumMath.equalsEpsilon(
+      ellipsoid._radii.x,
+      ellipsoid._radii.y,
+      CesiumMath.EPSILON15
+    )
+  ) {
+    // Ellipsoid curvature calculations assume radii.x === radii.y as is true for WGS84
+    return;
+  }
+
+  uniformState._eyeEllipsoidCurvature = ellipsoid.getLocalCurvature(
+    surfacePosition,
+    uniformState._eyeEllipsoidCurvature
+  );
 }
 
 let transformMatrix = new Matrix3();
@@ -1293,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/Scene/ArcGisMapService.js

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

package/Source/Scene/Atmosphere.js

@@ -0,0 +1,127 @@
+import Cartesian3 from "../Core/Cartesian3.js";
+import DynamicAtmosphereLightingType from "./DynamicAtmosphereLightingType.js";
+
+/**
+ * Common atmosphere settings used by 3D Tiles and models for rendering sky atmosphere, ground atmosphere, and fog.
+ *
+ * <p>
+ * This class is not to be confused with {@link SkyAtmosphere}, which is responsible for rendering the sky.
+ * </p>
+ * <p>
+ * While the atmosphere settings affect the color of fog, see {@link Fog} to control how fog is rendered.
+ * </p>
+ *
+ * @alias Atmosphere
+ * @constructor
+ *
+ * @example
+ * // Turn on dynamic atmosphere lighting using the sun direction
+ * scene.atmosphere.dynamicLighting = Cesium.DynamicAtmosphereLightingType.SUNLIGHT;
+ *
+ * @example
+ * // Turn on dynamic lighting using whatever light source is in the scene
+ * scene.light = new Cesium.DirectionalLight({
+ *   direction: new Cesium.Cartesian3(1, 0, 0)
+ * });
+ * scene.atmosphere.dynamicLighting = Cesium.DynamicAtmosphereLightingType.SCENE_LIGHT;
+ *
+ * @example
+ * // Adjust the color of the atmosphere effects.
+ * scene.atmosphere.hueShift = 0.4; // Cycle 40% around the color wheel
+ * scene.atmosphere.brightnessShift = 0.25; // Increase the brightness
+ * scene.atmosphere.saturationShift = -0.1; // Desaturate the colors
+ *
+ * @see SkyAtmosphere
+ * @see Globe
+ * @see Fog
+ */
+function Atmosphere() {
+  /**
+   * The intensity of the light that is used for computing the ground atmosphere color.
+   *
+   * @type {number}
+   * @default 10.0
+   */
+  this.lightIntensity = 10.0;
+
+  /**
+   * The Rayleigh scattering coefficient used in the atmospheric scattering equations for the ground atmosphere.
+   *
+   * @type {Cartesian3}
+   * @default Cartesian3(5.5e-6, 13.0e-6, 28.4e-6)
+   */
+  this.rayleighCoefficient = new Cartesian3(5.5e-6, 13.0e-6, 28.4e-6);
+
+  /**
+   * The Mie scattering coefficient used in the atmospheric scattering equations for the ground atmosphere.
+   *
+   * @type {Cartesian3}
+   * @default Cartesian3(21e-6, 21e-6, 21e-6)
+   */
+  this.mieCoefficient = new Cartesian3(21e-6, 21e-6, 21e-6);
+
+  /**
+   * The Rayleigh scale height used in the atmospheric scattering equations for the ground atmosphere, in meters.
+   *
+   * @type {number}
+   * @default 10000.0
+   */
+  this.rayleighScaleHeight = 10000.0;
+
+  /**
+   * The Mie scale height used in the atmospheric scattering equations for the ground atmosphere, in meters.
+   *
+   * @type {number}
+   * @default 3200.0
+   */
+  this.mieScaleHeight = 3200.0;
+
+  /**
+   * The anisotropy of the medium to consider for Mie scattering.
+   * <p>
+   * Valid values are between -1.0 and 1.0.
+   * </p>
+   *
+   * @type {number}
+   * @default 0.9
+   */
+  this.mieAnisotropy = 0.9;
+
+  /**
+   * The hue shift to apply to the atmosphere. Defaults to 0.0 (no shift).
+   * A hue shift of 1.0 indicates a complete rotation of the hues available.
+   *
+   * @type {number}
+   * @default 0.0
+   */
+  this.hueShift = 0.0;
+
+  /**
+   * The saturation shift to apply to the atmosphere. Defaults to 0.0 (no shift).
+   * A saturation shift of -1.0 is monochrome.
+   *
+   * @type {number}
+   * @default 0.0
+   */
+  this.saturationShift = 0.0;
+
+  /**
+   * The brightness shift to apply to the atmosphere. Defaults to 0.0 (no shift).
+   * A brightness shift of -1.0 is complete darkness, which will let space show through.
+   *
+   * @type {number}
+   * @default 0.0
+   */
+  this.brightnessShift = 0.0;
+
+  /**
+   * When not DynamicAtmosphereLightingType.NONE, the selected light source will
+   * be used for dynamically lighting all atmosphere-related rendering effects.
+   *
+   * @type {DynamicAtmosphereLightingType}
+   * @default DynamicAtmosphereLightingType.NONE
+   */
+  this.dynamicLighting = DynamicAtmosphereLightingType.NONE;
+}
+
+export default Atmosphere;