@hztxi/cesium-engine 25.0.3 → 25.0.4

package/Source/Scene/ImageryLayer.js

@@ -1,4 +1,5 @@
 import Cartesian2 from "../Core/Cartesian2.js";
+import Cartesian3 from "../Core/Cartesian3.js";
 import Cartesian4 from "../Core/Cartesian4.js";
 import Check from "../Core/Check.js";
 import createWorldImageryAsync from "../Scene/createWorldImageryAsync.js";
@@ -171,12 +172,92 @@ import TileImagery from "./TileImagery.js";
  * const imageryLayer = new ImageryLayer(imageryProvider);
  * tileset.imageryLayers.add(imageryLayer);
  */
+// Clamps chosen so a mistyped profile cannot wash out the imagery entirely.
+const LEVEL_COLOR_MIN_SCALE = 0.5;
+const LEVEL_COLOR_MAX_SCALE = 2.0;
+const LEVEL_COLOR_MAX_OFFSET = 0.25;
+
+function clampLevelColorValue(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+
+/**
+ * Converts a public levelColorProfile object into per-level gain/bias pairs
+ * with the correction strength already folded in:
+ * gain = 1 + strength * (scale - 1), bias = strength * offset.
+ *
+ * @param {object|undefined} profile The public profile object.
+ * @returns {object|undefined} Map of level to {gain, bias}, or undefined.
+ * @private
+ */
+function normalizeLevelColorProfile(profile) {
+  if (!defined(profile) || !defined(profile.levels)) {
+    return undefined;
+  }
+
+  const strength = clampLevelColorValue(profile.strength ?? 1.0, 0.0, 1.0);
+  const entries = {};
+  for (const level of Object.keys(profile.levels)) {
+    const entry = profile.levels[level];
+    if (!defined(entry)) {
+      continue;
+    }
+    const scale = defined(entry.scale) ? entry.scale : [1, 1, 1];
+    const offset = defined(entry.offset) ? entry.offset : [0, 0, 0];
+    entries[level] = {
+      gain: new Cartesian3(
+        clampLevelColorValue(
+          1.0 + strength * (scale[0] - 1.0),
+          LEVEL_COLOR_MIN_SCALE,
+          LEVEL_COLOR_MAX_SCALE,
+        ),
+        clampLevelColorValue(
+          1.0 + strength * (scale[1] - 1.0),
+          LEVEL_COLOR_MIN_SCALE,
+          LEVEL_COLOR_MAX_SCALE,
+        ),
+        clampLevelColorValue(
+          1.0 + strength * (scale[2] - 1.0),
+          LEVEL_COLOR_MIN_SCALE,
+          LEVEL_COLOR_MAX_SCALE,
+        ),
+      ),
+      bias: new Cartesian3(
+        clampLevelColorValue(
+          strength * offset[0],
+          -LEVEL_COLOR_MAX_OFFSET,
+          LEVEL_COLOR_MAX_OFFSET,
+        ),
+        clampLevelColorValue(
+          strength * offset[1],
+          -LEVEL_COLOR_MAX_OFFSET,
+          LEVEL_COLOR_MAX_OFFSET,
+        ),
+        clampLevelColorValue(
+          strength * offset[2],
+          -LEVEL_COLOR_MAX_OFFSET,
+          LEVEL_COLOR_MAX_OFFSET,
+        ),
+      ),
+    };
+  }
+  return { entries };
+}
+
 function ImageryLayer(imageryProvider, options) {
   this._imageryProvider = imageryProvider;
 
   this._readyEvent = new Event();
   this._errorEvent = new Event();
 
+  // Normalized form of the public levelColorProfile: per-level gain/bias
+  // Cartesian3 pairs with the correction strength already folded in.
+  this._levelColorProfile = undefined;
+  this._levelColorProfileInput = undefined;
+
+  this._levelColorEdgeBlend = 0.0;
+  this._levelColorEdgeCrossFade = true;
+
   options = options ?? Frozen.EMPTY_OBJECT;
   imageryProvider = imageryProvider ?? Frozen.EMPTY_OBJECT;
 
@@ -372,6 +453,116 @@ Object.defineProperties(ImageryLayer.prototype, {
     },
   },
 
+  /**
+   * Gets or sets a per-level color correction profile for this layer. Imagery
+   * pyramids from third-party providers are frequently assembled from different
+   * mosaic vintages per level, which shows up as a visible color seam wherever
+   * two levels are rendered next to each other (typically in tilted views).
+   * The profile applies one per-channel affine transform
+   * (<code>scale * color + offset</code>, normalized [0, 1] units) to every
+   * tile of a given level, which makes adjacent levels visually continuous.
+   * Levels not listed in the profile are left uncorrected.
+   *
+   * The profile is a plain object, typically generated by the
+   * <code>Apps/LevelColorCalibration.html</code> tool, of the form:
+   * <pre>{
+   *   "strength": 0.8,
+   *   "referenceLevel": 16,
+   *   "levels": {
+   *     "14": { "scale": [1.02, 1.01, 0.98], "offset": [-0.01, 0.0, 0.02] },
+   *     "17": { "scale": [0.99, 1.0, 1.03],  "offset": [0.0, -0.01, 0.03] }
+   *   }
+   * }</pre>
+   * <code>strength</code> (default <code>1.0</code>) blends between the original
+   * and corrected color, <code>(1 - strength) * original + strength * (scale * original + offset)</code>,
+   * so values below 1 keep some of the original per-level character.
+   *
+   * Assigning a profile takes effect immediately, without reloading tiles;
+   * setting it to <code>undefined</code> disables the correction.
+   *
+   * @memberof ImageryLayer.prototype
+   * @type {object|undefined}
+   * @default undefined
+   *
+   * @example
+   * const response = await fetch("level-color-profile.json");
+   * layer.levelColorProfile = await response.json();
+   */
+  levelColorProfile: {
+    get: function () {
+      return this._levelColorProfileInput;
+    },
+    set: function (value) {
+      this._levelColorProfileInput = value;
+      this._levelColorProfile = normalizeLevelColorProfile(value);
+    },
+  },
+
+  /**
+   * Gets or sets the width, as a fraction of the tile's extent, of an
+   * edge band where this tile's {@link ImageryLayer#levelColorProfile}
+   * correction is smoothly faded into the correction of the adjacent
+   * coarser tile's level. Residual color steps at imagery LOD boundaries
+   * (levels that cannot fully converge, or local deviations from the
+   * calibration statistics) become gradual ramps, which are far less
+   * visible than abrupt steps. The fade is one-sided: only the finer
+   * side of a boundary fades, so both sides apply the same correction
+   * exactly at the shared edge. Requires a levelColorProfile; edges
+   * facing same-level or finer neighbors are not blended.
+   *
+   * The value is clamped to [0.0, 0.45]; 0 disables the fade. Values
+   * between 0.15 and 0.25 are a good starting point. Takes effect
+   * immediately (uniform-only after the first enabling, which compiles
+   * one additional shader variant).
+   *
+   * @memberof ImageryLayer.prototype
+   * @type {number}
+   * @default 0.0
+   */
+  levelColorEdgeBlend: {
+    get: function () {
+      return this._levelColorEdgeBlend;
+    },
+    set: function (value) {
+      //>>includeStart('debug', pragmas.debug);
+      if (defined(value) && typeof value !== "number") {
+        throw new DeveloperError("value must be a number.");
+      }
+      //>>includeEnd('debug');
+      this._levelColorEdgeBlend = defined(value)
+        ? CesiumMath.clamp(value, 0.0, 0.45)
+        : 0.0;
+    },
+  },
+  /**
+   * Gets or sets whether the {@link ImageryLayer#levelColorEdgeBlend} band
+   * cross-fades the imagery CONTENT with the ancestor imagery at the
+   * adjacent coarser tile's level (the very texture the coarser side
+   * renders), instead of only fading the correction parameters. Content
+   * cross-fading makes both sides of a boundary pixel-identical at the
+   * shared edge, which also removes seams caused by content differences
+   * (mosaic vintage, local deviations from the calibration statistics)
+   * that a correction-parameter fade cannot touch. When the ancestor
+   * texture is unavailable, the parameter fade is used as a fallback.
+   * Requires a levelColorProfile and levelColorEdgeBlend &gt; 0.
+   *
+   * @memberof ImageryLayer.prototype
+   * @type {boolean}
+   * @default true
+   */
+  levelColorEdgeCrossFade: {
+    get: function () {
+      return this._levelColorEdgeCrossFade;
+    },
+    set: function (value) {
+      //>>includeStart('debug', pragmas.debug);
+      if (defined(value) && typeof value !== "boolean") {
+        throw new DeveloperError("value must be a boolean.");
+      }
+      //>>includeEnd('debug');
+      this._levelColorEdgeCrossFade = value ?? true;
+    },
+  },
   /**
    * Returns true when the terrain provider has been successfully created. Otherwise, returns false.
    * @memberof ImageryLayer.prototype
@@ -1047,6 +1238,21 @@ ImageryLayer.prototype._createTileImagerySkeletons = function (
   return true;
 };
 
+/**
+ * Returns the normalized color correction for tiles of the given imagery
+ * level, or <code>undefined</code> if the level is not in this layer's
+ * {@link ImageryLayer#levelColorProfile}.
+ *
+ * @param {number} level The imagery level.
+ * @returns {object|undefined} An object with <code>gain</code> and
+ *          <code>bias</code> {@link Cartesian3} properties.
+ *
+ * @private
+ */
+ImageryLayer.prototype._getLevelColorCorrection = function (level) {
+  return this._levelColorProfile?.entries[level];
+};
+
 /**
  * Calculate the translation and scale for a particular {@link TileImagery} attached to a
  * particular terrain tile.
@@ -1062,12 +1268,39 @@ ImageryLayer.prototype._calculateTextureTranslationAndScale = function (
   tile,
   tileImagery,
 ) {
-  let imageryRectangle = tileImagery.readyImagery.rectangle;
+  return this._calculateImageryTranslationAndScale(
+    tile,
+    tileImagery.readyImagery,
+    tileImagery.useWebMercatorT,
+    new Cartesian4(),
+  );
+};
+
+/**
+ * Calculates the translation and scale mapping a terrain tile's 0..1 UV into the
+ * UV space of an arbitrary {@link Imagery} of this layer covering the tile,
+ * writing into {@link result}. Works for coarser ancestors as well: the math only
+ * depends on the two rectangles.
+ *
+ * @private
+ *
+ * @param {Tile} tile The terrain tile.
+ * @param {Imagery} imagery The imagery whose texture space to map into.
+ * @param {boolean} useWebMercatorT Whether the sampling tile uses the Web Mercator T coordinate.
+ * @param {Cartesian4} result The Cartesian4 (x/y translation, z/w scale) to fill.
+ * @returns {Cartesian4} The result.
+ */
+ImageryLayer.prototype._calculateImageryTranslationAndScale = function (
+  tile,
+  imagery,
+  useWebMercatorT,
+  result,
+) {
+  let imageryRectangle = imagery.rectangle;
   let terrainRectangle = tile.rectangle;
 
-  if (tileImagery.useWebMercatorT) {
-    const tilingScheme =
-      tileImagery.readyImagery.imageryLayer.imageryProvider.tilingScheme;
+  if (useWebMercatorT) {
+    const tilingScheme = this.imageryProvider.tilingScheme;
     imageryRectangle = tilingScheme.rectangleToNativeRectangle(
       imageryRectangle,
       imageryBoundsScratch,
@@ -1083,13 +1316,14 @@ ImageryLayer.prototype._calculateTextureTranslationAndScale = function (
 
   const scaleX = terrainWidth / imageryRectangle.width;
   const scaleY = terrainHeight / imageryRectangle.height;
-  return new Cartesian4(
-    (scaleX * (terrainRectangle.west - imageryRectangle.west)) / terrainWidth,
+  result.x =
+    (scaleX * (terrainRectangle.west - imageryRectangle.west)) / terrainWidth;
+  result.y =
     (scaleY * (terrainRectangle.south - imageryRectangle.south)) /
-      terrainHeight,
-    scaleX,
-    scaleY,
-  );
+    terrainHeight;
+  result.z = scaleX;
+  result.w = scaleY;
+  return result;
 };
 
 /**

package/Source/Scene/QuadtreePrimitive.js

@@ -4,6 +4,7 @@ import defined from "../Core/defined.js";
 import DeveloperError from "../Core/DeveloperError.js";
 import Event from "../Core/Event.js";
 import getTimestamp from "../Core/getTimestamp.js";
+import IntersectionTests from "../Core/IntersectionTests.js";
 import CesiumMath from "../Core/Math.js";
 import Matrix4 from "../Core/Matrix4.js";
 import OrthographicFrustum from "../Core/OrthographicFrustum.js";
@@ -109,6 +110,36 @@ function QuadtreePrimitive(options) {
    */
   this.maximumScreenSpaceError = options.maximumScreenSpaceError ?? 2;
 
+  /**
+   * Gets or sets the uniform level-of-detail mode configuration, pushed down
+   * from {@link Globe#uniformLevelMode} every frame. When enabled, tile
+   * refinement is evaluated against a single per-frame reference distance
+   * instead of each tile's own distance, so visible tiles converge on one
+   * level instead of a distance-dependent mix. See updateUniformLevelState
+   * for the recognized fields.
+   *
+   * @type {object|undefined}
+   * @default undefined
+   */
+  this.uniformLevelMode = undefined;
+
+  // Per-frame uniform-level state, recomputed in beginFrame and consumed by
+  // screenSpaceError. version marks the uniformLevelMode implementation
+  // revision (1: initial, 2: nearest-fallback + clamp for Columbus,
+  // 3: maxCoarsenLevels near-side clamp); it lets callers detect which
+  // engine build they are actually running against.
+  this._uniformLevelState = {
+    version: 3,
+    active: false,
+    engage: 0.0,
+    referenceDistance: undefined,
+    deviationFactor: 8.0,
+    coarsenFactor: 2.0,
+  };
+  this._nearestTileDistanceThisFrame = undefined;
+  this._nearestTileDistanceLastFrame = undefined;
+  this._uniformLevelFrameNumber = -1;
+
   /**
    * Gets or sets the maximum number of tiles that will be retained in the tile cache.
    * Note that tiles will never be unloaded if they were used for rendering the last
@@ -343,6 +374,8 @@ QuadtreePrimitive.prototype.beginFrame = function (frameState) {
 
   clearTileLoadQueue(this);
 
+  updateUniformLevelState(this, frameState);
+
   if (this._debug.suspendLodUpdate) {
     return;
   }
@@ -722,6 +755,20 @@ function visitTile(
 
   ++debug.tilesVisited;
 
+  // Track the nearest visible tile distance for uniform-level mode's
+  // "nearest" reference. computeTileVisibility has already refreshed
+  // tile._distance for this frame by the time a tile is visited.
+  const uniformMode = primitive.uniformLevelMode;
+  if (defined(uniformMode) && uniformMode.enabled === true) {
+    const tileDistance = tile._distance;
+    if (defined(tileDistance)) {
+      const nearest = primitive._nearestTileDistanceThisFrame;
+      if (!defined(nearest) || tileDistance < nearest) {
+        primitive._nearestTileDistanceThisFrame = tileDistance;
+      }
+    }
+  }
+
   primitive._tileReplacementQueue.markTileRendered(tile);
   tile.updateCustomData();
 
@@ -1245,6 +1292,176 @@ function visitIfVisible(
   tile._lastSelectionResultFrame = frameState.frameNumber;
 }
 
+const uniformLevelScratchUp = new Cartesian3();
+const uniformLevelScratchRay = new Ray();
+
+/**
+ * Recomputes the per-frame uniform-level state consumed by screenSpaceError.
+ *
+ * Uniform-level mode makes tiles in view converge on one LOD level by
+ * evaluating refinement against a single per-frame reference distance instead
+ * of each tile's own distance:
+ *
+ *   reference: "center" (default) uses the camera-to-globe-center distance
+ *              along the view ray; "nearest" uses the distance of the nearest
+ *              visible tile from the previous frame.
+ *   maxDeviationLevels (default 3) caps how many levels above the natural LOD
+ *              far tiles may be forced to refine, bounding the tile-count
+ *              increase toward the horizon.
+ *   maxCoarsenLevels (default 1, clamped to [0, 10]) caps how many levels
+ *              below the natural LOD near (foreground) tiles may be held
+ *              back. Uncapped, the foreground of a tilted far view lands
+ *              2+ levels coarser than natural, and verticalExaggeration > 1
+ *              multiplies the interpolation error of coarse terrain
+ *              (1 level = 4x, 2 levels = 16x) into visible tearing. 1
+ *              measures +0~4% tile requests; 0 makes the foreground fully
+ *              natural (+5~69% requests) but mixes near/far levels again,
+ *              bringing back the dataset's cross-level color bands.
+ *   pitchRangeDegrees (default undefined = always engaged) is a [full, none]
+ *              pair of pitch angles; the effect fades out between them as the
+ *              view approaches the horizon. Pass null or leave undefined to
+ *              keep it fully engaged (e.g. for offline export).
+ *
+ * The effect is blended in by an engage factor, and the reference distance is
+ * EMA-smoothed (snapping across large jumps, e.g. camera cuts during export)
+ * so the selected level does not flap frame to frame.
+ *
+ * @private
+ */
+function updateUniformLevelState(primitive, frameState) {
+  const state = primitive._uniformLevelState;
+  state.active = false;
+  state.engage = 0.0;
+
+  // Roll over nearest-tile-distance tracking once per frame. Multiple render
+  // passes can occur within one frame (as in 2D), so key on frame number.
+  if (primitive._uniformLevelFrameNumber !== frameState.frameNumber) {
+    primitive._uniformLevelFrameNumber = frameState.frameNumber;
+    primitive._nearestTileDistanceLastFrame =
+      primitive._nearestTileDistanceThisFrame;
+    primitive._nearestTileDistanceThisFrame = undefined;
+  }
+
+  const mode = primitive.uniformLevelMode;
+  if (!defined(mode) || mode.enabled !== true) {
+    // Drop stale smoothing state so re-enabling starts fresh.
+    state.referenceDistance = undefined;
+    return;
+  }
+
+  // The 3D SSE path (perspective frustum) is the distance-dependent one, and
+  // it is used in both SCENE3D and Columbus view, so both need the mode.
+  // True 2D (SCENE2D) SSE is already distance-independent.
+  const isColumbusView = frameState.mode === SceneMode.COLUMBUS_VIEW;
+  if (frameState.mode !== SceneMode.SCENE3D && !isColumbusView) {
+    return;
+  }
+
+  const camera = frameState.camera;
+  const alignment = CesiumMath.clamp(
+    -Cartesian3.dot(
+      Cartesian3.normalize(camera.positionWC, uniformLevelScratchUp),
+      camera.directionWC,
+    ),
+    0.0,
+    1.0,
+  );
+  // alignment is 1.0 looking straight down and 0.0 at or above the horizon.
+
+  let engage = 1.0;
+  const pitchRange = mode.pitchRangeDegrees;
+  if (defined(pitchRange) && pitchRange !== null) {
+    const fullAlignment = Math.sin(
+      CesiumMath.toRadians(Math.abs(pitchRange[0])),
+    );
+    const noneAlignment = Math.sin(
+      CesiumMath.toRadians(Math.abs(pitchRange[1])),
+    );
+    const alignmentRange = Math.max(fullAlignment - noneAlignment, 1e-6);
+    let t = (alignment - noneAlignment) / alignmentRange;
+    t = CesiumMath.clamp(t, 0.0, 1.0);
+    engage = t * t * (3.0 - 2.0 * t);
+  }
+  if (engage <= 0.0) {
+    return;
+  }
+
+  let referenceDistance;
+  const nearestDistance = primitive._nearestTileDistanceLastFrame;
+  if (mode.reference === "nearest") {
+    referenceDistance = nearestDistance;
+  } else if (isColumbusView) {
+    // In Columbus view the flattened map is the x = 0 plane in world
+    // coordinates (see pickMapColumbusView): the center-of-view distance is
+    // the view ray parameter where it crosses that plane.
+    const directionX = camera.directionWC.x;
+    if (directionX !== 0.0) {
+      const scalar = -camera.positionWC.x / directionX;
+      referenceDistance = scalar > 0.0 ? scalar : undefined;
+    }
+    // The plane math assumes the default Columbus embedding; a camera
+    // reference transform (lookAt etc.) or animation-driven position can
+    // break the sign assumptions. Fall back to the tracked nearest tile
+    // distance, which is frame-consistent no matter how the camera got
+    // there.
+    if (!defined(referenceDistance)) {
+      referenceDistance = nearestDistance;
+    }
+  } else {
+    const ray = uniformLevelScratchRay;
+    Cartesian3.clone(camera.positionWC, ray.origin);
+    Cartesian3.clone(camera.directionWC, ray.direction);
+    const intersection = IntersectionTests.rayEllipsoid(
+      ray,
+      primitive._tileProvider.tilingScheme.ellipsoid,
+    );
+    referenceDistance = defined(intersection) ? intersection.start : undefined;
+  }
+  // Horizon-looking views miss the ground entirely; fall back to the nearest
+  // tracked distance there too so the mode stays engaged.
+  if (!defined(referenceDistance)) {
+    referenceDistance = nearestDistance;
+  }
+  // Sanity clamp: keep the reference within an order of magnitude of the
+  // nearest visible tile distance, so a degenerate camera frame cannot
+  // demand levels far outside what visible tiles can plausibly load.
+  if (
+    defined(referenceDistance) &&
+    defined(nearestDistance) &&
+    nearestDistance > 0.0
+  ) {
+    referenceDistance = Math.min(referenceDistance, 8.0 * nearestDistance);
+  }
+  if (!defined(referenceDistance) || referenceDistance <= 0.0) {
+    // No ground along the view ray (or no tracking yet): leave inactive.
+    return;
+  }
+
+  // Smooth the reference distance to avoid level flapping, but snap across
+  // large discontinuities (camera cuts, e.g. per-frame seeks in export).
+  const previous = state.referenceDistance;
+  if (defined(previous) && previous > 0.0) {
+    const ratio = referenceDistance / previous;
+    referenceDistance =
+      ratio < 0.5 || ratio > 2.0
+        ? referenceDistance
+        : previous + 0.25 * (referenceDistance - previous);
+  }
+
+  const maxDeviationLevels = CesiumMath.clamp(
+    mode.maxDeviationLevels ?? 3,
+    0,
+    10,
+  );
+  const maxCoarsenLevels = CesiumMath.clamp(mode.maxCoarsenLevels ?? 1, 0, 10);
+
+  state.referenceDistance = referenceDistance;
+  state.engage = engage;
+  state.deviationFactor = Math.pow(2.0, maxDeviationLevels);
+  state.coarsenFactor = Math.pow(2.0, maxCoarsenLevels);
+  state.active = true;
+}
+
 function screenSpaceError(primitive, frameState, tile) {
   if (
     frameState.mode === SceneMode.SCENE2D ||
@@ -1263,9 +1480,46 @@ function screenSpaceError(primitive, frameState, tile) {
 
   let error = (maxGeometricError * height) / (distance * sseDenominator);
 
+  const uniformLevel = primitive._uniformLevelState;
+  if (uniformLevel.active) {
+    // Uniform-level mode: evaluate this tile as if it sat at the reference
+    // distance, so every tile refines to the level appropriate for one
+    // representative distance instead of its own. The clamp bounds how far
+    // the selection may drift from natural in either direction (each level
+    // is a factor of two in error): far tiles may be pushed at most
+    // maxDeviationLevels levels finer (bounding tile-count growth toward the
+    // horizon), and near tiles held at most maxCoarsenLevels levels coarser.
+    // Without the near-side clamp, the foreground of a tilted far view lands
+    // 2+ levels coarse, and terrain exaggeration (verticalExaggeration > 1)
+    // amplifies coarse-terrain interpolation error (4x per level) into
+    // visible tearing. engage blends between natural and uniform selection.
+    const uniformError =
+      (maxGeometricError * height) /
+      (uniformLevel.referenceDistance * sseDenominator);
+    const cappedUniformError = CesiumMath.clamp(
+      uniformError,
+      error / uniformLevel.coarsenFactor,
+      error * uniformLevel.deviationFactor,
+    );
+    error += (cappedUniformError - error) * uniformLevel.engage;
+  }
+
   if (frameState.fog.enabled) {
-    error -=
-      CesiumMath.fog(distance, frameState.fog.density) * frameState.fog.sse;
+    let fogAmount = CesiumMath.fog(distance, frameState.fog.density);
+    if (uniformLevel.active) {
+      // Blend the fog SSE relief toward the relief at the reference distance
+      // so every tile gets the same effective threshold. Subtracting each
+      // tile's own (larger, distance-dependent) relief instead would satisfy
+      // the SSE for far tiles on fog alone, vetoing the uniform refinement
+      // and reintroducing cross-level boundaries beyond the fog onset
+      // distance. Fog shading itself is unaffected; only LOD selection.
+      const uniformFogAmount = CesiumMath.fog(
+        uniformLevel.referenceDistance,
+        frameState.fog.density,
+      );
+      fogAmount += (uniformFogAmount - fogAmount) * uniformLevel.engage;
+    }
+    error -= fogAmount * frameState.fog.sse;
   }
 
   error /= frameState.pixelRatio;

package/Source/Shaders/GlobeFS.glsl

@@ -26,6 +26,39 @@ uniform float u_dayTextureBrightness[TEXTURE_UNITS];
 uniform float u_dayTextureContrast[TEXTURE_UNITS];
 #endif
 
+#ifdef APPLY_TONE_MATCH
+uniform vec3 u_dayTextureToneGain[TEXTURE_UNITS];
+uniform vec3 u_dayTextureToneBias[TEXTURE_UNITS];
+#endif
+
+#ifdef APPLY_TONE_MATCH_EDGE
+// Per-texture fade targets at the four geographic edges of the surface tile
+// (index order: 0 = south, 1 = east, 2 = north, 3 = west).
+// u_dayTextureToneEdgeBlend holds one band width per geographic edge as a
+// fraction of the tile extent; only edges with a coarser neighbor get a
+// positive width, so same-level/finer edges never participate in the fade
+// (an edge that faded toward the texture's own correction would reset the
+// fade contributed by another edge near their corner).
+uniform vec3 u_dayTextureToneEdgeGain[TEXTURE_UNITS * 4];
+uniform vec3 u_dayTextureToneEdgeBias[TEXTURE_UNITS * 4];
+uniform float u_dayTextureToneEdgeBlend[TEXTURE_UNITS * 4];
+#endif
+
+#ifdef APPLY_TONE_MATCH_CROSS
+// Per-texture ancestor imagery for content cross-fading at edges facing a
+// coarser neighbor: near such an edge the tile blends its full rendered result
+// with the ancestor's rendering (ancestor texture sampled with the ancestor
+// level's correction), making both sides of the boundary identical at the
+// shared edge. u_dayTextureCrossBlend holds one band width per geographic edge
+// (0 = south, 1 = east, 2 = north, 3 = west); an edge only fades when its
+// neighbor's imagery level matches the bound ancestor's level.
+uniform sampler2D u_dayTextureCrossTexture[TEXTURE_UNITS];
+uniform vec4 u_dayTextureCrossTranslationAndScale[TEXTURE_UNITS];
+uniform vec3 u_dayTextureCrossGain[TEXTURE_UNITS];
+uniform vec3 u_dayTextureCrossBias[TEXTURE_UNITS];
+uniform float u_dayTextureCrossBlend[TEXTURE_UNITS * 4];
+#endif
+
 #ifdef APPLY_HUE
 uniform float u_dayTextureHue[TEXTURE_UNITS];
 #endif
@@ -199,6 +232,8 @@ vec4 sampleAndBlend(
     float textureHue,
     float textureSaturation,
     float textureOneOverGamma,
+    vec3 textureToneGain,
+    vec3 textureToneBias,
     float split,
     vec4 colorToAlpha,
     float nightBlend)
@@ -227,6 +262,13 @@ vec4 sampleAndBlend(
     vec3 color = value.rgb;
     float alpha = value.a;
 
+#ifdef APPLY_TONE_MATCH
+    // Applied directly after sampling so the affine correction, which is fitted
+    // in source-image color space, commutes with the identical transforms that
+    // follow for both the tile and the imagery it replaces.
+    color = color * textureToneGain + textureToneBias;
+#endif
+
 #ifdef APPLY_COLOR_TO_ALPHA
     vec3 colorDiff = abs(color.rgb - colorToAlpha.rgb);
     colorDiff.r = czm_maximumComponent(colorDiff);
@@ -690,3 +732,4 @@ vec4 computeWaterColor(vec3 positionEyeCoordinates, vec2 textureCoordinates, mat
 }
 
 #endif // #ifdef SHOW_REFLECTIVE_OCEAN
+