@hztxi/cesium-engine 25.0.2 → 25.0.4

package/Build/Workers/upsampleVerticesFromCesium3DTilesTerrain.js

@@ -1,7 +1,7 @@
 /**
  * @license
  * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.141.2
+ * Version 1.141.4
  *
  * Copyright 2011-2022 Cesium Contributors
  *
@@ -25,33 +25,33 @@
 
 import {
   Cesium3DTilesTerrainGeometryProcessor_default
-} from "./chunk-RHVCL4BF.js";
-import "./chunk-LC2DM3UY.js";
-import "./chunk-MNKWZJLE.js";
-import "./chunk-65RILO72.js";
+} from "./chunk-FTRHXHI5.js";
+import "./chunk-UTKCX3AS.js";
+import "./chunk-AH6GJ5MT.js";
+import "./chunk-SUG6ECWR.js";
 import {
   createTaskProcessorWorker_default
-} from "./chunk-KM3TU6SW.js";
-import "./chunk-EJES53XD.js";
-import "./chunk-5BQXC3BP.js";
-import "./chunk-FYOU33DL.js";
-import "./chunk-53ITLB2Q.js";
-import "./chunk-2YHL3RU5.js";
-import "./chunk-DOJQOYSZ.js";
-import "./chunk-AIA3JN4E.js";
-import "./chunk-LFVZBOFT.js";
-import "./chunk-JHL6DEKL.js";
-import "./chunk-G7QZ6W7K.js";
-import "./chunk-7QXAVVZH.js";
-import "./chunk-SOMBAQ6X.js";
-import "./chunk-TT3NOX52.js";
-import "./chunk-VYTIQ2Y2.js";
-import "./chunk-AWP7JHXS.js";
-import "./chunk-RGNURFR5.js";
-import "./chunk-VDJVNJXW.js";
-import "./chunk-KGNDVO6V.js";
-import "./chunk-N4ECLSTH.js";
-import "./chunk-27UNFKLP.js";
+} from "./chunk-STXWAEVD.js";
+import "./chunk-EHXAKTME.js";
+import "./chunk-WDSHSR57.js";
+import "./chunk-FF6JKPLF.js";
+import "./chunk-KFRKYG4B.js";
+import "./chunk-642GMGGP.js";
+import "./chunk-65LZTCWG.js";
+import "./chunk-DNEERCHO.js";
+import "./chunk-CADDH6MK.js";
+import "./chunk-PXPUYOFJ.js";
+import "./chunk-Z3KHKVNA.js";
+import "./chunk-UNXJWCXV.js";
+import "./chunk-XQETP7YD.js";
+import "./chunk-IFSGYIDE.js";
+import "./chunk-ZQUSI7YK.js";
+import "./chunk-CJT3FTZK.js";
+import "./chunk-UDXUBVNR.js";
+import "./chunk-MD7CEJO5.js";
+import "./chunk-GH2D6MPO.js";
+import "./chunk-4MHUA5ZK.js";
+import "./chunk-PCXE4XMI.js";
 
 // packages/engine/Source/Workers/upsampleVerticesFromCesium3DTilesTerrain.js
 function upsampleVerticesFromCesium3DTilesTerrain(options, transferableObjects) {

package/Source/Core/ScreenSpaceEventHandler.js

@@ -19,6 +19,25 @@ function getPosition(screenSpaceEventHandler, event, result) {
   const rect = element.getBoundingClientRect();
   result.x = event.clientX - rect.left;
   result.y = event.clientY - rect.top;
+
+  // When CSS transforms (e.g. transform: scale) change the rendered size without
+  // changing layout clientWidth/clientHeight, event offsets are in "bounding rect"
+  // space while the rest of Cesium (Camera#getPickRay, picking, etc.) expects
+  // coordinates in clientWidth/clientHeight space. Map between the two.
+  const rectWidth = rect.width;
+  const rectHeight = rect.height;
+  const clientWidth = element.clientWidth;
+  const clientHeight = element.clientHeight;
+  if (
+    rectWidth > 0.0 &&
+    rectHeight > 0.0 &&
+    clientWidth > 0 &&
+    clientHeight > 0
+  ) {
+    result.x = (result.x * clientWidth) / rectWidth;
+    result.y = (result.y * clientHeight) / rectHeight;
+  }
+
   return result;
 }
 

package/Source/Scene/Globe.js

@@ -97,6 +97,60 @@ function Globe(ellipsoid) {
    */
   this.maximumScreenSpaceError = 2;
 
+  /**
+   * Gets or sets the uniform level-of-detail mode configuration. When enabled,
+   * tile refinement is evaluated against a single per-frame reference distance
+   * instead of each tile's own distance to the camera, so the tiles in view
+   * converge on one LOD level instead of a distance-dependent mix of levels.
+   * This eliminates visible cross-level seams (e.g. between differently-styled
+   * imagery levels) at the cost of loading more tiles in tilted views.
+   *
+   * The object has the following fields:
+   * <ul>
+   *   <li><code>enabled</code>: set to <code>true</code> to activate the mode.</li>
+   *   <li><code>reference</code>: which distance all tiles are evaluated against.
+   *       <code>"center"</code> (default) uses the distance from the camera to the
+   *       globe along the center of the view; <code>"nearest"</code> uses the
+   *       nearest visible tile distance from the previous frame, which selects
+   *       the highest detail level in view (more tiles).</li>
+   *   <li><code>maxDeviationLevels</code>: caps how many levels above the natural
+   *       LOD far tiles may be forced to refine (default <code>3</code>). Each
+   *       allowed level roughly quadruples the extra tile count toward the
+   *       horizon; lower values are cheaper, higher values are more uniform.</li>
+   *   <li><code>maxCoarsenLevels</code>: caps how many levels below the natural
+   *       LOD near (foreground) tiles may be held back (default <code>1</code>).
+   *       Uncapped, the foreground of a tilted far view lands 2+ levels coarser
+   *       than natural, and <code>verticalExaggeration &gt; 1</code> multiplies
+   *       the interpolation error of coarse terrain (1 level = 4x, 2 levels =
+   *       16x) into visible tearing. <code>1</code> measures +0~4% tile
+   *       requests over uncapped; <code>0</code> makes the foreground fully
+   *       natural (+5~69% requests) but mixes near/far levels again, bringing
+   *       back the dataset's cross-level color bands.</li>
+   *   <li><code>pitchRangeDegrees</code>: a <code>[full, none]</code> pair of pitch
+   *       angles in degrees (e.g. <code>[-50, -25]</code>) between which the effect
+   *       fades out as the view approaches the horizon. Leave undefined or pass
+   *       <code>null</code> to keep it fully engaged regardless of pitch, which is
+   *       appropriate for offline rendering.</li>
+   * </ul>
+   * Applies in {@link SceneMode.SCENE3D} and {@link SceneMode.COLUMBUS_VIEW};
+   * true 2D ({@link SceneMode.SCENE2D}) already uses distance-independent
+   * screen-space error and is unaffected.
+   *
+   * @type {object|undefined}
+   * @default undefined
+   *
+   * @example
+   * // Offline video export: full uniformity, no pitch gating
+   * globe.uniformLevelMode = {
+   *   enabled: true,
+   *   reference: "center",
+   *   maxDeviationLevels: 4,
+   *   maxCoarsenLevels: 1,
+   *   pitchRangeDegrees: null,
+   * };
+   */
+  this.uniformLevelMode = undefined;
+
   /**
    * The size of the terrain tile cache, expressed as a number of tiles.  Any additional
    * tiles beyond this number will be freed, as long as they aren't needed for rendering
@@ -1015,6 +1069,7 @@ Globe.prototype.beginFrame = function (frameState) {
     }
 
     surface.maximumScreenSpaceError = this.maximumScreenSpaceError;
+    surface.uniformLevelMode = this.uniformLevelMode;
     surface.tileCacheSize = this.tileCacheSize;
     surface.loadingDescendantLimit = this.loadingDescendantLimit;
     surface.preloadAncestors = this.preloadAncestors;

package/Source/Scene/GlobeSurfaceShaderSet.js

@@ -106,6 +106,9 @@ GlobeSurfaceShaderSet.prototype.getShaderProgram = function (options) {
   const applyHue = options.applyHue;
   const applySaturation = options.applySaturation;
   const applyGamma = options.applyGamma;
+  const applyToneMatch = options.applyToneMatch;
+  const applyToneMatchEdge = options.applyToneMatchEdge;
+  const applyToneMatchCross = options.applyToneMatchCross;
   const applyAlpha = options.applyAlpha;
   const applyDayNightAlpha = options.applyDayNightAlpha;
   const applySplit = options.applySplit;
@@ -197,7 +200,10 @@ GlobeSurfaceShaderSet.prototype.getShaderProgram = function (options) {
       (showUndergroundColor << 30) |
       (translucent << 31)) >>>
       0) +
-    (applyDayNightAlpha ? 0x100000000 : 0);
+    (applyDayNightAlpha ? 0x100000000 : 0) +
+    (applyToneMatch ? 0x200000000 : 0) +
+    (applyToneMatchEdge ? 0x400000000 : 0) +
+    (applyToneMatchCross ? 0x800000000 : 0);
 
   let currentClippingShaderState = 0;
   if (defined(clippingPlanes) && clippingPlanes.length > 0) {
@@ -279,6 +285,15 @@ GlobeSurfaceShaderSet.prototype.getShaderProgram = function (options) {
     if (applyGamma) {
       fs.defines.push("APPLY_GAMMA");
     }
+    if (applyToneMatch) {
+      fs.defines.push("APPLY_TONE_MATCH");
+    }
+    if (applyToneMatchEdge) {
+      fs.defines.push("APPLY_TONE_MATCH_EDGE");
+    }
+    if (applyToneMatchCross) {
+      fs.defines.push("APPLY_TONE_MATCH_CROSS");
+    }
     if (applyAlpha) {
       fs.defines.push("APPLY_ALPHA");
     }
@@ -396,6 +411,49 @@ GlobeSurfaceShaderSet.prototype.getShaderProgram = function (options) {
     }
 
     for (let i = 0; i < numberOfDayTextures; ++i) {
+      if (applyToneMatchEdge) {
+        computeDayColor += `\
+        vec3 toneGain${i} = u_dayTextureToneGain[${i}];
+        vec3 toneBias${i} = u_dayTextureToneBias[${i}];
+        {
+            // Per-edge sequential blend; edges with width 0 (same-level / finer /
+            // no neighbor) must NOT participate: an argmin over all four edge
+            // distances truncates the band into diagonal wedges at corners where
+            // an active edge meets an inactive one.
+            vec2 toneEdgeUV${i} = textureCoordinates.xy;
+            float toneEdgeW${i};
+            float toneEdgeT${i};
+            toneEdgeW${i} = u_dayTextureToneEdgeBlend[${i * 4}];
+            if (toneEdgeW${i} > 0.0) {
+                toneEdgeT${i} = smoothstep(0.0, toneEdgeW${i}, toneEdgeUV${i}.y);
+                toneGain${i} = mix(u_dayTextureToneEdgeGain[${i * 4}], toneGain${i}, toneEdgeT${i});
+                toneBias${i} = mix(u_dayTextureToneEdgeBias[${i * 4}], toneBias${i}, toneEdgeT${i});
+            }
+            toneEdgeW${i} = u_dayTextureToneEdgeBlend[${i * 4 + 1}];
+            if (toneEdgeW${i} > 0.0) {
+                toneEdgeT${i} = smoothstep(0.0, toneEdgeW${i}, 1.0 - toneEdgeUV${i}.x);
+                toneGain${i} = mix(u_dayTextureToneEdgeGain[${i * 4 + 1}], toneGain${i}, toneEdgeT${i});
+                toneBias${i} = mix(u_dayTextureToneEdgeBias[${i * 4 + 1}], toneBias${i}, toneEdgeT${i});
+            }
+            toneEdgeW${i} = u_dayTextureToneEdgeBlend[${i * 4 + 2}];
+            if (toneEdgeW${i} > 0.0) {
+                toneEdgeT${i} = smoothstep(0.0, toneEdgeW${i}, 1.0 - toneEdgeUV${i}.y);
+                toneGain${i} = mix(u_dayTextureToneEdgeGain[${i * 4 + 2}], toneGain${i}, toneEdgeT${i});
+                toneBias${i} = mix(u_dayTextureToneEdgeBias[${i * 4 + 2}], toneBias${i}, toneEdgeT${i});
+            }
+            toneEdgeW${i} = u_dayTextureToneEdgeBlend[${i * 4 + 3}];
+            if (toneEdgeW${i} > 0.0) {
+                toneEdgeT${i} = smoothstep(0.0, toneEdgeW${i}, toneEdgeUV${i}.x);
+                toneGain${i} = mix(u_dayTextureToneEdgeGain[${i * 4 + 3}], toneGain${i}, toneEdgeT${i});
+                toneBias${i} = mix(u_dayTextureToneEdgeBias[${i * 4 + 3}], toneBias${i}, toneEdgeT${i});
+            }
+        }
+`;
+      }
+      if (applyToneMatchCross) {
+        computeDayColor += `\
+        vec4 tonePrevColor${i} = color;\n`;
+      }
       if (hasImageryLayerCutout) {
         computeDayColor += `\
         cutoutAndColorResult = u_dayTextureCutoutRectangles[${i}];\n\
@@ -420,6 +478,20 @@ GlobeSurfaceShaderSet.prototype.getShaderProgram = function (options) {
             ${applyHue ? `u_dayTextureHue[${i}]` : "0.0"},\n\
             ${applySaturation ? `u_dayTextureSaturation[${i}]` : "0.0"},\n\
             ${applyGamma ? `u_dayTextureOneOverGamma[${i}]` : "0.0"},\n\
+            ${
+              applyToneMatchEdge
+                ? `toneGain${i}`
+                : applyToneMatch
+                  ? `u_dayTextureToneGain[${i}]`
+                  : "vec3(1.0)"
+            },\n\
+            ${
+              applyToneMatchEdge
+                ? `toneBias${i}`
+                : applyToneMatch
+                  ? `u_dayTextureToneBias[${i}]`
+                  : "vec3(0.0)"
+            },\n\
             ${applySplit ? `u_dayTextureSplit[${i}]` : "0.0"},\n\
             ${colorToAlpha ? `u_colorsToAlpha[${i}]` : "vec4(0.0)"},\n\
             nightBlend\);\n`;
@@ -428,6 +500,65 @@ GlobeSurfaceShaderSet.prototype.getShaderProgram = function (options) {
           "\
         color = czm_branchFreeTernary(texelUnclipped, cutoutAndColorResult, color);\n";
       }
+      if (applyToneMatchCross) {
+        computeDayColor += `\
+        if (u_dayTextureCrossBlend[${i * 4}] + u_dayTextureCrossBlend[${i * 4 + 1}] + u_dayTextureCrossBlend[${i * 4 + 2}] + u_dayTextureCrossBlend[${i * 4 + 3}] > 0.0) {
+            vec4 crossResult${i} = sampleAndBlend(
+                tonePrevColor${i},
+                u_dayTextureCrossTexture[${i}],
+                u_dayTextureUseWebMercatorT[${i}] ? textureCoordinates.xz : textureCoordinates.xy,
+                u_dayTextureTexCoordsRectangle[${i}],
+                u_dayTextureCrossTranslationAndScale[${i}],
+                ${applyAlpha ? `u_dayTextureAlpha[${i}]` : "1.0"},
+                ${applyDayNightAlpha ? `u_dayTextureNightAlpha[${i}]` : "1.0"},
+                ${applyDayNightAlpha ? `u_dayTextureDayAlpha[${i}]` : "1.0"},
+                ${applyBrightness ? `u_dayTextureBrightness[${i}]` : "0.0"},
+                ${applyContrast ? `u_dayTextureContrast[${i}]` : "0.0"},
+                ${applyHue ? `u_dayTextureHue[${i}]` : "0.0"},
+                ${applySaturation ? `u_dayTextureSaturation[${i}]` : "0.0"},
+                ${applyGamma ? `u_dayTextureOneOverGamma[${i}]` : "0.0"},
+                u_dayTextureCrossGain[${i}],
+                u_dayTextureCrossBias[${i}],
+                ${applySplit ? `u_dayTextureSplit[${i}]` : "0.0"},
+                ${colorToAlpha ? `u_colorsToAlpha[${i}]` : "vec4(0.0)"},
+                nightBlend);
+${
+  hasImageryLayerCutout
+    ? `\
+            crossResult${i} = czm_branchFreeTernary(texelUnclipped, crossResult${i}, tonePrevColor${i});\n`
+    : ""
+}\
+            // Only edges with a positive width participate; combining by min over
+            // active edges keeps the fade band anchored to the seam. An argmin over
+            // all four distances lets a width-0 edge win near active/inactive
+            // corners, truncating the band into periodic unblended wedges.
+            float crossT${i} = 1.0;
+            float crossW${i};
+            float crossTOne${i};
+            crossW${i} = u_dayTextureCrossBlend[${i * 4}];
+            if (crossW${i} > 0.0) {
+                crossTOne${i} = smoothstep(0.0, crossW${i}, textureCoordinates.y);
+                crossT${i} = min(crossT${i}, crossTOne${i});
+            }
+            crossW${i} = u_dayTextureCrossBlend[${i * 4 + 1}];
+            if (crossW${i} > 0.0) {
+                crossTOne${i} = smoothstep(0.0, crossW${i}, 1.0 - textureCoordinates.x);
+                crossT${i} = min(crossT${i}, crossTOne${i});
+            }
+            crossW${i} = u_dayTextureCrossBlend[${i * 4 + 2}];
+            if (crossW${i} > 0.0) {
+                crossTOne${i} = smoothstep(0.0, crossW${i}, 1.0 - textureCoordinates.y);
+                crossT${i} = min(crossT${i}, crossTOne${i});
+            }
+            crossW${i} = u_dayTextureCrossBlend[${i * 4 + 3}];
+            if (crossW${i} > 0.0) {
+                crossTOne${i} = smoothstep(0.0, crossW${i}, textureCoordinates.x);
+                crossT${i} = min(crossT${i}, crossTOne${i});
+            }
+            color = mix(crossResult${i}, color, crossT${i});
+        }
+`;
+      }
     }
 
     computeDayColor +=