@hztxi/cesium-engine 25.0.6 → 26.2.1

package/Source/Scene/Cesium3DTileStyle.js

@@ -76,6 +76,8 @@ function Cesium3DTileStyle(style) {
 
   // Vector Tiles in 3D Tiles 2.0.
   this._lineWidth = undefined;
+  this._polygonOutlineColor = undefined;
+  this._polygonOutlineWidth = undefined;
 
   this._colorShaderFunction = undefined;
   this._showShaderFunction = undefined;
@@ -122,6 +124,8 @@ function setup(that, styleJson) {
 
   // Vector Tiles in 3D Tiles 2.0.
   that.lineWidth = styleJson.lineWidth;
+  that.polygonOutlineColor = styleJson.polygonOutlineColor;
+  that.polygonOutlineWidth = styleJson.polygonOutlineWidth;
 
   const meta = {};
   if (defined(styleJson.meta)) {
@@ -1290,6 +1294,42 @@ Object.defineProperties(Cesium3DTileStyle.prototype, {
     },
   },
 
+  /**
+   * Internal-only, supported in Vector Tiles with 3D Tiles 2.0.
+   * @memberof Cesium3DTileStyle.prototype
+   * @type {StyleExpression}
+   * @ignore
+   */
+  polygonOutlineColor: {
+    get: function () {
+      return this._polygonOutlineColor;
+    },
+    set: function (value) {
+      this._polygonOutlineColor = getExpression(this, value);
+      this._style.polygonOutlineColor = getJsonFromExpression(
+        this._polygonOutlineColor,
+      );
+    },
+  },
+
+  /**
+   * Internal-only, supported in Vector Tiles with 3D Tiles 2.0.
+   * @memberof Cesium3DTileStyle.prototype
+   * @type {StyleExpression}
+   * @ignore
+   */
+  polygonOutlineWidth: {
+    get: function () {
+      return this._polygonOutlineWidth;
+    },
+    set: function (value) {
+      this._polygonOutlineWidth = getExpression(this, value);
+      this._style.polygonOutlineWidth = getJsonFromExpression(
+        this._polygonOutlineWidth,
+      );
+    },
+  },
+
   /**
    * Internal-only, supported in Vector Tiles with 3D Tiles 2.0.
    * @memberof Cesium3DTileStyle.prototype

package/Source/Scene/Cesium3DTileset.js

@@ -42,6 +42,7 @@ import Cesium3DTilesetStatistics from "./Cesium3DTilesetStatistics.js";
 import Cesium3DTileStyleEngine from "./Cesium3DTileStyleEngine.js";
 import ClippingPlaneCollection from "./ClippingPlaneCollection.js";
 import ClippingPolygonCollection from "./ClippingPolygonCollection.js";
+import EdgeDisplayMode from "./EdgeDisplayMode.js";
 import hasExtension from "./hasExtension.js";
 import ImplicitTileset from "./ImplicitTileset.js";
 import ImplicitTileCoordinates from "./ImplicitTileCoordinates.js";
@@ -75,6 +76,8 @@ import ImageryLayerCollection from "./ImageryLayerCollection.js";
  * @property {Axis} [modelForwardAxis=Axis.X] Which axis is considered forward when loading models for tile contents.
  * @property {ShadowMode} [shadows=ShadowMode.ENABLED] Determines whether the tileset casts or receives shadows from light sources.
  * @property {number} [maximumScreenSpaceError=16] The maximum screen space error used to drive level of detail refinement.
+ * @property {object} [uniformLevelMode] Evaluates tile refinement against a shared
+ * per-frame reference distance so visible tiles converge on a uniform level.
  * @property {number} [cacheBytes=536870912] The size (in bytes) to which the tile cache will be trimmed, if the cache contains tiles not needed for the current view.
  * @property {number} [maximumCacheOverflowBytes=536870912] The maximum additional memory (in bytes) to allow for cache headroom, if more than {@link Cesium3DTileset#cacheBytes} are needed for the current view.
  * @property {boolean} [cullWithChildrenBounds=true] Optimization option. Whether to cull tiles using the union of their children bounding volumes.
@@ -99,10 +102,11 @@ import ImageryLayerCollection from "./ImageryLayerCollection.js";
  * @property {number} [skipLevels=1] When <code>skipLevelOfDetail</code> is <code>true</code>, a constant defining the minimum number of levels to skip when loading tiles. When it is 0, no levels are skipped. Used in conjunction with <code>skipScreenSpaceErrorFactor</code> to determine which tiles to load.
  * @property {boolean} [immediatelyLoadDesiredLevelOfDetail=false] When <code>skipLevelOfDetail</code> is <code>true</code>, only tiles that meet the maximum screen space error will ever be downloaded. Skipping factors are ignored and just the desired tiles are loaded.
  * @property {boolean} [loadSiblings=false] When <code>skipLevelOfDetail</code> is <code>true</code>, determines whether siblings of visible tiles are always downloaded during traversal.
+ * @property {number} [maximumSimultaneousTileRequests=Infinity] Maximum number of this tileset's tile network requests that may be pending at once.
  * @property {ClippingPlaneCollection} [clippingPlanes] The {@link ClippingPlaneCollection} used to selectively disable rendering the tileset.
  * @property {ClippingPolygonCollection} [clippingPolygons] The {@link ClippingPolygonCollection} used to selectively disable rendering the tileset.
  * @property {ClassificationType} [classificationType] Determines whether terrain, 3D Tiles or both will be classified by this tileset. See {@link Cesium3DTileset#classificationType} for details about restrictions and limitations.
- * @property {HeightReference} [heightReference] Sets the {@link HeightReference} for point features in vector tilesets.
+ * @property {HeightReference} [heightReference] Sets the {@link HeightReference} for features in vector tilesets.
  * @property {Scene} [scene] The {@link CesiumWidget#scene} that the tileset will be rendered in, required for tilesets that specify a {@link heightReference} value for clamping 3D Tiles vector data content- like points, lines, and labels- to terrain or 3D tiles.
  * @property {Ellipsoid} [ellipsoid=Ellipsoid.WGS84] The ellipsoid determining the size and shape of the globe.
  * @property {object} [pointCloudShading] Options for constructing a {@link PointCloudShading} object to control point attenuation based on geometric error and lighting.
@@ -128,6 +132,7 @@ import ImageryLayerCollection from "./ImageryLayerCollection.js";
  * @property {boolean} [debugColorizeTiles=false] For debugging only. When true, assigns a random color to each tile.
  * @property {boolean} [enableDebugWireframe=false] For debugging only. This must be true for debugWireframe to work in WebGL1. This cannot be set after the tileset has been created.
  * @property {boolean} [debugWireframe=false] For debugging only. When true, render's each tile's content as a wireframe.
+ * @property {EdgeDisplayMode} [edgeDisplayMode=EdgeDisplayMode.SURFACES_ONLY] Controls how edges from the {@link https://github.com/KhronosGroup/glTF/pull/2479|EXT_mesh_primitive_edge_visibility} glTF extension are rendered relative to surface geometry.
  * @property {boolean} [debugShowBoundingVolume=false] For debugging only. When true, renders the bounding volume for each tile.
  * @property {boolean} [debugShowContentBoundingVolume=false] For debugging only. When true, renders the bounding volume for each tile's content.
  * @property {boolean} [debugShowViewerRequestVolume=false] For debugging only. When true, renders the viewer request volume for each tile.
@@ -242,6 +247,17 @@ function Cesium3DTileset(options) {
 
   this._maximumScreenSpaceError = options.maximumScreenSpaceError ?? 16;
   this._memoryAdjustedScreenSpaceError = this._maximumScreenSpaceError;
+  this._uniformLevelMode = options.uniformLevelMode;
+  this._uniformLevelState = {
+    active: false,
+    engage: 0.0,
+    referenceDistance: undefined,
+    deviationFactor: 8.0,
+    coarsenFactor: 2.0,
+  };
+  this._nearestTileDistanceThisFrame = undefined;
+  this._nearestTileDistanceLastFrame = undefined;
+  this._uniformLevelFrameNumber = -1;
 
   this._cacheBytes = options.cacheBytes ?? 512 * 1024 * 1024;
   //>>includeStart('debug', pragmas.debug);
@@ -759,6 +775,30 @@ function Cesium3DTileset(options) {
 
   this._disableSkipLevelOfDetail = false;
 
+  /**
+   * Optional runtime content codec injected by data providers
+   * (e.g. {@link MVTDataProvider}). When set, {@link Cesium3DTile} bypasses
+   * the standard magic-number / URL based content dispatch and delegates
+   * content construction to <code>codec.createContent(...)</code>. This
+   * keeps format-specific logic out of the runtime.
+   *
+   * Shape:
+   *   {
+   *     contentType: string,                 // diagnostic only
+   *     disableSkipLevelOfDetail?: boolean,
+   *     createContent: (tileset, tile, resource, arrayBuffer) => Promise<Cesium3DTileContent>,
+   *     missingTilePolicy?: { statusCodes?: number[] }
+   *       // A missing tile policy specifies HTTP Status Codes to be interpreted
+   *       // as "no content", and rendered as empty tiles, rather than throwing
+   *       // errors or retrying the request. Allows tiles to be statically hosted,
+   *       // without generating and serving unnecessary content for empty tiles.
+   *   }
+   *
+   * @type {object|undefined}
+   * @ignore
+   */
+  this._runtimeContentCodec = undefined;
+
   /**
    * The screen space error that must be reached before skipping levels of detail.
    * <p>
@@ -820,6 +860,16 @@ function Cesium3DTileset(options) {
    */
   this.loadSiblings = options.loadSiblings ?? false;
 
+  /**
+   * Maximum number of this tileset's tile network requests that may be
+   * pending at once.
+   *
+   * @type {number}
+   * @default Infinity
+   */
+  this.maximumSimultaneousTileRequests =
+    options.maximumSimultaneousTileRequests ?? Number.POSITIVE_INFINITY;
+
   this._clippingPlanes = undefined;
   if (defined(options.clippingPlanes)) {
     ClippingPlaneCollection.setOwner(
@@ -957,6 +1007,20 @@ function Cesium3DTileset(options) {
     );
   }
 
+  /**
+   * Controls how edges from the
+   * {@link https://github.com/KhronosGroup/glTF/pull/2479|EXT_mesh_primitive_edge_visibility}
+   * glTF extension are rendered relative to surface geometry. Tile content
+   * primitives that do not declare the extension are unaffected.
+   *
+   * @type {EdgeDisplayMode}
+   * @default EdgeDisplayMode.SURFACES_ONLY
+   *
+   * @experimental This feature is using part of the glTF spec that is not yet final and is subject to change without Cesium's standard deprecation policy.
+   */
+  this.edgeDisplayMode =
+    options.edgeDisplayMode ?? EdgeDisplayMode.SURFACES_ONLY;
+
   /**
    * This property is for debugging only; it is not optimized for production use.
    * <p>
@@ -1515,6 +1579,27 @@ Object.defineProperties(Cesium3DTileset.prototype, {
     },
   },
 
+  /**
+   * Uniform level-of-detail configuration. When enabled, perspective screen-space
+   * error is blended toward the error at a single reference distance, preventing
+   * visible tiles at different distances from selecting different levels solely
+   * because of distance.
+   *
+   * @memberof Cesium3DTileset.prototype
+   *
+   * @type {object|undefined}
+   */
+  uniformLevelMode: {
+    get: function () {
+      return this._uniformLevelMode;
+    },
+    set: function (value) {
+      this._uniformLevelMode = value;
+      this._uniformLevelState.active = false;
+      this._uniformLevelState.referenceDistance = undefined;
+    },
+  },
+
   /**
    * The amount of GPU memory (in bytes) used to cache tiles. This memory usage is estimated from
    * geometry, textures, and batch table textures of loaded tiles. For point clouds, this value also
@@ -2632,7 +2717,7 @@ function sortTilesByPriority(a, b) {
 
 /**
  * Perform any pass invariant tasks here. Called after the render pass.
- * @private
+ * @ignore
  * @param {FrameState} frameState
  */
 Cesium3DTileset.prototype.postPassesUpdate = function (frameState) {
@@ -2655,7 +2740,7 @@ Cesium3DTileset.prototype.postPassesUpdate = function (frameState) {
 
 /**
  * Perform any pass invariant tasks here. Called before any passes are executed.
- * @private
+ * @ignore
  * @param {FrameState} frameState
  */
 Cesium3DTileset.prototype.prePassesUpdate = function (frameState) {
@@ -2708,11 +2793,14 @@ function cancelOutOfViewRequests(tileset, frameState) {
 
     // NOTE: This is framerate dependant so make sure the threshold check is small
     const outOfView = frameState.frameNumber - tile._touchedFrame >= 1;
+    const noLongerDesired =
+      tileset.immediatelyLoadDesiredLevelOfDetail &&
+      tile._desiredFrame !== frameState.frameNumber;
     if (tile._contentState !== Cesium3DTileContentState.LOADING) {
       // No longer fetching from host, don't need to track it anymore. Gets marked as LOADING in Cesium3DTile::requestContent().
       ++removeCount;
       continue;
-    } else if (outOfView) {
+    } else if (outOfView || noLongerDesired) {
       // RequestScheduler will take care of cancelling it
       tile.cancelRequests();
       ++removeCount;
@@ -2736,7 +2824,13 @@ function cancelOutOfViewRequests(tileset, frameState) {
 function requestTiles(tileset) {
   const requestedTiles = tileset._requestedTiles;
   requestedTiles.sort(sortTilesByPriority);
-  for (let i = 0; i < requestedTiles.length; ++i) {
+  const availableRequests = Math.max(
+    0,
+    tileset.maximumSimultaneousTileRequests -
+      tileset._requestedTilesInFlight.length,
+  );
+  const requestCount = Math.min(requestedTiles.length, availableRequests);
+  for (let i = 0; i < requestCount; ++i) {
     requestContent(tileset, requestedTiles[i]);
   }
 }
@@ -2915,6 +3009,115 @@ function decreaseScreenSpaceError(tileset) {
   );
 }
 
+const uniformLevelScratchUp = new Cartesian3();
+const uniformLevelScratchRay = new Ray();
+
+/**
+ * Compute the shared reference distance and engagement used by uniform-level SSE.
+ * @private
+ * @param {Cesium3DTileset} tileset
+ * @param {FrameState} frameState
+ */
+function updateUniformLevelState(tileset, frameState) {
+  const state = tileset._uniformLevelState;
+  if (tileset._uniformLevelFrameNumber !== frameState.frameNumber) {
+    tileset._uniformLevelFrameNumber = frameState.frameNumber;
+    tileset._nearestTileDistanceLastFrame =
+      tileset._nearestTileDistanceThisFrame;
+    tileset._nearestTileDistanceThisFrame = undefined;
+  }
+  state.active = false;
+
+  const mode = tileset._uniformLevelMode;
+  if (!defined(mode) || mode.enabled !== true) {
+    state.referenceDistance = undefined;
+    return;
+  }
+
+  const camera = frameState.camera;
+  const alignment = CesiumMath.clamp(
+    -Cartesian3.dot(
+      Cartesian3.normalize(camera.positionWC, uniformLevelScratchUp),
+      camera.directionWC,
+    ),
+    0.0,
+    1.0,
+  );
+
+  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 interpolation = (alignment - noneAlignment) / alignmentRange;
+    interpolation = CesiumMath.clamp(interpolation, 0.0, 1.0);
+    engage = interpolation * interpolation * (3.0 - 2.0 * interpolation);
+  }
+  if (engage <= 0.0) {
+    return;
+  }
+
+  let referenceDistance;
+  const nearestDistance = tileset._nearestTileDistanceLastFrame;
+  if (mode.reference === "nearest") {
+    referenceDistance = nearestDistance;
+  } else if (frameState.mode === SceneMode.COLUMBUS_VIEW) {
+    const directionX = camera.directionWC.x;
+    if (directionX !== 0.0) {
+      const scalar = -camera.positionWC.x / directionX;
+      referenceDistance = scalar > 0.0 ? scalar : undefined;
+    }
+  } else {
+    Cartesian3.clone(camera.positionWC, uniformLevelScratchRay.origin);
+    Cartesian3.clone(camera.directionWC, uniformLevelScratchRay.direction);
+    const intersection = IntersectionTests.rayEllipsoid(
+      uniformLevelScratchRay,
+      tileset.ellipsoid,
+    );
+    referenceDistance = defined(intersection) ? intersection.start : undefined;
+  }
+
+  if (!defined(referenceDistance) && defined(nearestDistance)) {
+    referenceDistance = nearestDistance;
+  }
+  if (
+    defined(referenceDistance) &&
+    defined(nearestDistance) &&
+    nearestDistance > 0.0
+  ) {
+    referenceDistance = Math.min(referenceDistance, 8.0 * nearestDistance);
+  }
+  if (!defined(referenceDistance) || referenceDistance <= 0.0) {
+    return;
+  }
+
+  const previous = state.referenceDistance;
+  if (defined(previous) && previous > 0.0) {
+    const ratio = referenceDistance / previous;
+    if (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 = 2 ** maxDeviationLevels;
+  state.coarsenFactor = 2 ** maxCoarsenLevels;
+  state.active = true;
+}
+
 const scratchCartesian = new Cartesian3();
 
 const stringOptions = {
@@ -3393,6 +3596,8 @@ function update(tileset, frameState, passStatistics, passOptions) {
   // Update any tracked min max values
   resetMinimumMaximum(tileset);
 
+  updateUniformLevelState(tileset, frameState);
+
   detectModelMatrixChanged(tileset, frameState);
   tileset._cullRequestsWhileMoving =
     tileset.cullRequestsWhileMoving && !tileset._modelMatrixChanged;
@@ -3477,7 +3682,7 @@ Cesium3DTileset.prototype.getTraversal = function (passOptions) {
 };
 
 /**
- * @private
+ * @ignore
  * @param {FrameState} frameState
  */
 Cesium3DTileset.prototype.update = function (frameState) {
@@ -3485,7 +3690,7 @@ Cesium3DTileset.prototype.update = function (frameState) {
 };
 
 /**
- * @private
+ * @ignore
  * @param {FrameState} frameState
  * @param {object} tilesetPassState
  */
@@ -3670,11 +3875,11 @@ Cesium3DTileset.supportedExtensions = {
   "3DTILES_metadata": true,
   "3DTILES_implicit_tiling": true,
   "3DTILES_content_gltf": true,
+  "3DTILES_content_gltf_vector": true,
   "3DTILES_multiple_contents": true,
   "3DTILES_bounding_volume_S2": true,
   "3DTILES_batch_table_hierarchy": true,
   "3DTILES_draco_point_compression": true,
-  CESIUM_mesh_vector: true,
   MAXAR_content_geojson: true,
 };
 

package/Source/Scene/Cesium3DTilesetTraversal.js

@@ -130,6 +130,9 @@ Cesium3DTilesetTraversal.touchTile = function (tile, frameState) {
  */
 Cesium3DTilesetTraversal.loadTile = function (tile, frameState) {
   const { tileset } = tile;
+  if (tileset.immediatelyLoadDesiredLevelOfDetail) {
+    tile._desiredFrame = frameState.frameNumber;
+  }
   if (
     tile._requestedFrame === frameState.frameNumber ||
     (!tile.hasUnloadedRenderableContent && !tile.contentExpired)
@@ -189,6 +192,17 @@ function isOnScreenLongEnough(tile, frameState) {
  */
 Cesium3DTilesetTraversal.updateTile = function (tile, frameState) {
   updateTileVisibility(tile, frameState);
+  const uniformMode = tile.tileset.uniformLevelMode;
+  if (
+    defined(uniformMode) &&
+    uniformMode.enabled === true &&
+    defined(tile._distanceToCamera)
+  ) {
+    const nearest = tile.tileset._nearestTileDistanceThisFrame;
+    if (!defined(nearest) || tile._distanceToCamera < nearest) {
+      tile.tileset._nearestTileDistanceThisFrame = tile._distanceToCamera;
+    }
+  }
   tile.updateExpiration();
 
   tile._wasMinPriorityChild = false;

package/Source/Scene/ClippingPlaneCollection.js

@@ -545,8 +545,8 @@ ClippingPlaneCollection.prototype.update = function (frameState) {
   }
   if (!this._multipleDirtyPlanes) {
     // partial updates possible
-    let offsetX = 0;
-    let offsetY = 0;
+    let offsetX;
+    let offsetY;
     if (useFloatTexture) {
       offsetY = Math.floor(dirtyIndex / clippingPlanesTexture.width);
       offsetX = Math.floor(dirtyIndex - offsetY * clippingPlanesTexture.width);
@@ -605,7 +605,7 @@ const scratchMatrix = new Matrix4();
 const scratchPlane = new Plane(Cartesian3.UNIT_X, 0.0);
 /**
  * Determines the type intersection with the planes of this ClippingPlaneCollection instance and the specified {@link TileBoundingVolume}.
- * @private
+ * @ignore
  *
  * @param {object} tileBoundingVolume The volume to determine the intersection with the planes.
  * @param {Matrix4} [transform] An optional, additional matrix to transform the plane to world coordinates.
@@ -656,7 +656,7 @@ ClippingPlaneCollection.prototype.computeIntersectionWithBoundingVolume =
  * @param {ClippingPlaneCollection} [clippingPlaneCollection] A ClippingPlaneCollection (or undefined) being attached to an object
  * @param {object} owner An Object that should receive the new ClippingPlaneCollection
  * @param {string} key The Key for the Object to reference the ClippingPlaneCollection
- * @private
+ * @ignore
  */
 ClippingPlaneCollection.setOwner = function (
   clippingPlaneCollection,

package/Source/Scene/ClippingPolygon.js

@@ -84,6 +84,7 @@ function ClippingPolygon(options) {
  *
  * @param {Cartesian3[]|undefined} input The input array
  * @returns {Cartesian3[]|undefined} The copy
+ * @ignore
  */
 function copyArrayCartesian3(input) {
   if (!defined(input)) {
@@ -110,6 +111,7 @@ function copyArrayCartesian3(input) {
  * @param {Cartesian3[]|undefined} a The first array
  * @param {Cartesian3[]|undefined} b The second array
  * @returns {boolean} Whether the arrays are equal
+ * @ignore
  */
 function equalsArrayCartesian3(a, b) {
   if (!defined(a) && !defined(b)) {

package/Source/Scene/ClippingPolygonCollection.js

@@ -897,7 +897,7 @@ const scratchRectangleIntersection = new Rectangle();
 const scratchRectanglePolygon = new Rectangle();
 /**
  * Determines the type intersection with the polygons of this ClippingPolygonCollection instance and the specified {@link TileBoundingVolume}.
- * @private
+ * @ignore
  *
  * @param {object} tileBoundingVolume The volume to determine the intersection with the polygons.
  * @param {Ellipsoid} [ellipsoid=Ellipsoid.default] The ellipsoid on which the bounding volumes are defined.
@@ -963,7 +963,7 @@ ClippingPolygonCollection.prototype.computeIntersectionWithBoundingVolume =
  * @param {ClippingPolygonCollection} [clippingPolygonsCollection] A ClippingPolygonCollection (or undefined) being attached to an object
  * @param {object} owner An Object that should receive the new ClippingPolygonCollection
  * @param {string} key The Key for the Object to reference the ClippingPolygonCollection
- * @private
+ * @ignore
  */
 ClippingPolygonCollection.setOwner = function (
   clippingPolygonsCollection,