@hztxi/cesium-engine 25.0.7 → 26.2.2

package/Source/Scene/CameraEventAggregator.js

@@ -8,12 +8,29 @@ import ScreenSpaceEventHandler from "../Core/ScreenSpaceEventHandler.js";
 import ScreenSpaceEventType from "../Core/ScreenSpaceEventType.js";
 import CameraEventType from "./CameraEventType.js";
 
-function getKey(type, modifier) {
-  let key = `${type}`;
-  if (defined(modifier)) {
-    key += `+${modifier}`;
+const keyboardModifierCombinations = [
+  KeyboardEventModifier.SHIFT,
+  KeyboardEventModifier.CTRL,
+  KeyboardEventModifier.ALT,
+  [KeyboardEventModifier.SHIFT, KeyboardEventModifier.CTRL],
+  [KeyboardEventModifier.SHIFT, KeyboardEventModifier.ALT],
+  [KeyboardEventModifier.CTRL, KeyboardEventModifier.ALT],
+  [
+    KeyboardEventModifier.SHIFT,
+    KeyboardEventModifier.CTRL,
+    KeyboardEventModifier.ALT,
+  ],
+];
+
+function getKey(type, modifiers) {
+  if (!defined(modifiers)) {
+    return `${type}`;
   }
-  return key;
+
+  const modifierList = Array.isArray(modifiers)
+    ? modifiers.toSorted()
+    : [modifiers];
+  return `${type}+${modifierList.join("+")}`;
 }
 
 function clonePinchMovement(pinchMovement, result) {
@@ -219,7 +236,7 @@ function listenMouseButtonDownUp(aggregator, modifier, type) {
   aggregator._eventHandler.setInputAction(
     function () {
       cancelMouseDownAction(getKey(type, undefined), aggregator);
-      for (const modifier of Object.values(KeyboardEventModifier)) {
+      for (const modifier of keyboardModifierCombinations) {
         const cancelKey = getKey(type, modifier);
         cancelMouseDownAction(cancelKey, aggregator);
       }
@@ -382,18 +399,13 @@ function CameraEventAggregator(canvas) {
   listenMouseButtonDownUp(this, undefined, CameraEventType.MIDDLE_DRAG);
   listenMouseMove(this, undefined);
 
-  for (const modifierName in KeyboardEventModifier) {
-    if (KeyboardEventModifier.hasOwnProperty(modifierName)) {
-      const modifier = KeyboardEventModifier[modifierName];
-      if (defined(modifier)) {
-        listenToWheel(this, modifier);
-        listenToPinch(this, modifier, canvas);
-        listenMouseButtonDownUp(this, modifier, CameraEventType.LEFT_DRAG);
-        listenMouseButtonDownUp(this, modifier, CameraEventType.RIGHT_DRAG);
-        listenMouseButtonDownUp(this, modifier, CameraEventType.MIDDLE_DRAG);
-        listenMouseMove(this, modifier);
-      }
-    }
+  for (const modifiers of keyboardModifierCombinations) {
+    listenToWheel(this, modifiers);
+    listenToPinch(this, modifiers, canvas);
+    listenMouseButtonDownUp(this, modifiers, CameraEventType.LEFT_DRAG);
+    listenMouseButtonDownUp(this, modifiers, CameraEventType.RIGHT_DRAG);
+    listenMouseButtonDownUp(this, modifiers, CameraEventType.MIDDLE_DRAG);
+    listenMouseMove(this, modifiers);
   }
 }
 

package/Source/Scene/CameraFlightPath.js

@@ -438,10 +438,13 @@ CameraFlightPath.createTween = function (scene, options) {
 
   const camera = scene.camera;
 
-  if (mode === SceneMode.COLUMBUS_VIEW && scene.columbusRepeatWorlds === true) {
-    // Columbus repeat worlds: fly to the copy of the destination nearest the
-    // camera's current copy so the flight pans locally instead of crossing a
-    // full world. In local (u, v, h) coordinates, u is the x component.
+  if (
+    (mode === SceneMode.SCENE2D || mode === SceneMode.COLUMBUS_VIEW) &&
+    scene.columbusRepeatWorlds === true
+  ) {
+    // Repeat worlds: fly to the copy of the destination nearest the camera's
+    // current copy so the flight pans locally instead of crossing a full
+    // world. In local (u, v, h) coordinates, u is the x component.
     scratchDestination.x = ColumbusWorlds.nearestWorldU(
       camera.position.x,
       destination.x,

package/Source/Scene/Cesium3DTile.js

@@ -503,6 +503,7 @@ function Cesium3DTile(tileset, baseResource, header, parent) {
   this._selectedFrame = 0;
   this._wasSelectedLastFrame = false;
   this._requestedFrame = 0;
+  this._desiredFrame = 0;
   this._ancestorWithContent = undefined;
   this._ancestorWithContentAvailable = undefined;
   this._refines = false;
@@ -944,13 +945,34 @@ Cesium3DTile.prototype.getScreenSpaceError = function (
     error = geometricError / pixelSize;
   } else {
     // Avoid divide by zero when viewer is inside the tile
-    const distance = Math.max(this._distanceToCamera, CesiumMath.EPSILON7);
+    const tileDistance = Math.max(this._distanceToCamera, CesiumMath.EPSILON7);
     const sseDenominator = frustum.sseDenominator;
-    error = (geometricError * height) / (distance * sseDenominator);
+    error = (geometricError * height) / (tileDistance * sseDenominator);
+    const uniformLevel = tileset._uniformLevelState;
+    if (uniformLevel.active) {
+      const referenceDistance = Math.max(
+        uniformLevel.referenceDistance,
+        CesiumMath.EPSILON7,
+      );
+      const uniformError =
+        (geometricError * height) / (referenceDistance * sseDenominator);
+      const cappedUniformError = CesiumMath.clamp(
+        uniformError,
+        error / uniformLevel.coarsenFactor,
+        error * uniformLevel.deviationFactor,
+      );
+      error += (cappedUniformError - error) * uniformLevel.engage;
+    }
     if (tileset.dynamicScreenSpaceError) {
       const density = tileset._dynamicScreenSpaceErrorComputedDensity;
       const factor = tileset.dynamicScreenSpaceErrorFactor;
-      const dynamicError = CesiumMath.fog(distance, density) * factor;
+      let dynamicError = CesiumMath.fog(tileDistance, density) * factor;
+      if (uniformLevel.active) {
+        const uniformDynamicError =
+          CesiumMath.fog(uniformLevel.referenceDistance, density) * factor;
+        dynamicError +=
+          (uniformDynamicError - dynamicError) * uniformLevel.engage;
+      }
       error -= dynamicError;
     }
   }
@@ -1232,6 +1254,16 @@ async function processArrayBuffer(
       return;
     }
 
+    if (isEmptyTile(tile, error)) {
+      if (expired) {
+        tile.expireDate = undefined;
+      }
+      tile._content = new Empty3DTileContent(tileset, tile);
+      markTileAsEmptyContent(tile);
+      tile._contentState = Cesium3DTileContentState.PROCESSING;
+      return tile._content;
+    }
+
     tile._contentState = Cesium3DTileContentState.FAILED;
     throw error;
   }
@@ -1256,6 +1288,7 @@ async function processArrayBuffer(
 
     if (tile.isDestroyed()) {
       // Tile is unloaded before the content can process
+      destroyUnattachedContent(content);
       return;
     }
 
@@ -1264,6 +1297,9 @@ async function processArrayBuffer(
     }
 
     tile._content = content;
+    if (content instanceof Empty3DTileContent) {
+      markTileAsEmptyContent(tile);
+    }
     tile._contentState = Cesium3DTileContentState.PROCESSING;
 
     return content;
@@ -1316,6 +1352,49 @@ function requestSingleContent(tile) {
   return processArrayBuffer(tile, tileset, request, expired, promise);
 }
 
+/**
+ * Determines whether a tile load error should be interpreted as "no content"
+ * (empty tile) rather than a true failure. A missing tile policy specifies
+ * HTTP Status Codes to be interpreted as "no content", allowing tiles to be
+ * statically hosted without generating and serving unnecessary content for
+ * empty tiles.
+ * @ignore
+ */
+function isEmptyTile(tile, error) {
+  const tileset = tile._tileset;
+  const policy = tileset?._runtimeContentCodec?.missingTilePolicy;
+  if (!defined(policy)) {
+    return false;
+  }
+
+  if (!defined(error.statusCode)) {
+    return false;
+  }
+  return policy.statusCodes.includes(error.statusCode);
+}
+
+function markTileAsEmptyContent(tile) {
+  // These flags are mutable instance state initialized in the constructor.
+  tile.hasEmptyContent = true;
+  tile.hasRenderableContent = false;
+}
+
+/**
+ * Releases content that was constructed but never attached to its tile, which
+ * happens when the tile is destroyed while the payload is still decoding. Some
+ * content types register themselves with shared owners during construction, so
+ * dropping the reference alone would leak.
+ * @param {Cesium3DTileContent|undefined} content
+ * @private
+ */
+function destroyUnattachedContent(content) {
+  if (defined(content) && !content.isDestroyed()) {
+    content.destroy();
+  }
+}
+
+Cesium3DTile._isEmptyTile = isEmptyTile;
+
 /**
  * Given a downloaded content payload, construct a {@link Cesium3DTileContent}.
  * <p>
@@ -1328,10 +1407,29 @@ function requestSingleContent(tile) {
  * @private
  */
 async function makeContent(tile, arrayBuffer) {
+  const tileset = tile._tileset;
+  const codec = tileset?._runtimeContentCodec;
+  // Runtime codecs own leaf payloads. Implicit placeholder tiles first load a
+  // subtree JSON/binary payload, which must continue through normal dispatch
+  // so it can expand into the codec's derived content tiles.
+  if (
+    !defined(tile.implicitTileset) &&
+    defined(codec) &&
+    typeof codec.createContent === "function"
+  ) {
+    const content = await Promise.resolve(
+      codec.createContent(tileset, tile, tile._contentResource, arrayBuffer),
+    );
+    if (tile.isDestroyed()) {
+      destroyUnattachedContent(content);
+      return;
+    }
+    return content;
+  }
+
   const preprocessed = preprocess3DTileContent(arrayBuffer);
 
   // Vector and Geometry tile rendering do not support the skip LOD optimization.
-  const tileset = tile._tileset;
   tileset._disableSkipLevelOfDetail =
     tileset._disableSkipLevelOfDetail ||
     preprocessed.contentType === Cesium3DTileContentType.GEOMETRY ||