@hztxi/cesium-engine 25.0.6 → 26.2.1

package/Source/Scene/Picking.js

@@ -247,6 +247,7 @@ const scratchColorZero = new Color(0.0, 0.0, 0.0, 0.0);
  * height will default to the value of <code>width</code>
  * @param {BoundingRectangle} result The result rectangle
  * @returns {BoundingRectangle} The result rectangle
+ * @ignore
  */
 function computePickingDrawingBufferRectangle(
   drawingBufferHeight,
@@ -265,21 +266,31 @@ function computePickingDrawingBufferRectangle(
 /**
  * Setup needed before picking.
  *
+ * Exported for use by Snapping, which performs the same offscreen pick render
+ * but targets the snap framebuffer and flags the pass as a snapping pass.
+ *
  * @param {Scene} scene
  * @param {Cartesian2} windowPosition Window coordinates to perform picking on.
  * @param {BoundingRectangle} drawingBufferRectangle The output drawing buffer recangle.
  * @param {number} [width=3] Width of the pick rectangle.
  * @param {number} [height=3] Height of the pick rectangle.
+ * @param {object} [options] Object with the following properties:
+ * @param {PickFramebuffer|SnapFramebuffer} [options.framebuffer] The framebuffer to render into. Defaults to the view's pick framebuffer.
+ * @param {boolean} [options.snap=false] If <code>true</code>, mark the pass as a snapping pass (sets <code>frameState.passes.snap</code>).
+ *
+ * @private
  */
-function pickBegin(
+export function pickBegin(
   scene,
   windowPosition,
   drawingBufferRectangle,
   width,
   height,
+  options,
 ) {
   const { context, frameState, defaultView } = scene;
   const { viewport, pickFramebuffer } = defaultView;
+  const framebuffer = options?.framebuffer ?? pickFramebuffer;
 
   scene.view = defaultView;
 
@@ -316,13 +327,14 @@ function pickBegin(
   );
   frameState.invertClassification = false;
   frameState.passes.pick = true;
+  frameState.passes.snap = options?.snap ?? false;
   frameState.tilesetPassState = pickTilesetPassState;
 
   context.uniformState.update(frameState);
 
   scene.updateEnvironment();
 
-  passState = pickFramebuffer.begin(drawingBufferRectangle, viewport);
+  passState = framebuffer.begin(drawingBufferRectangle, viewport);
 
   scene.updateAndExecuteCommands(passState, scratchColorZero);
   scene.resolveFramebuffers(passState);
@@ -332,8 +344,10 @@ function pickBegin(
  * Teardown needed after picking.
  *
  * @param {Scene} scene
+ *
+ * @private
  */
-function pickEnd(scene) {
+export function pickEnd(scene) {
   const { context } = scene;
   context.endFrame();
 }
@@ -808,6 +822,7 @@ Picking.prototype.pickPosition = function (scene, windowPosition, result) {
  * @param {object[]} pickedAttributes
  * @param {object[]} pickedFeatures
  * @returns {boolean} whether picking should end
+ * @ignore
  */
 function addDrillPickedResults(
   pickedResults,
@@ -875,6 +890,7 @@ function addDrillPickedResults(
  * @param {function(number): object[]} pickCallback Pick callback to execute each iteration
  * @param {number} [limit=Number.MAX_VALUE] If supplied, stop drilling after collecting this many picks
  * @returns {object[]} List of picked results
+ * @ignore
  */
 function drillPick(pickCallback, limit) {
   // PERFORMANCE_IDEA: This function calls each primitive's update for each pass. Instead

package/Source/Scene/PlanarFillIdFramebuffer.js

@@ -0,0 +1,172 @@
+import defined from "../Core/defined.js";
+import destroyObject from "../Core/destroyObject.js";
+import PixelFormat from "../Core/PixelFormat.js";
+import Color from "../Core/Color.js";
+import PixelDatatype from "../Renderer/PixelDatatype.js";
+import FramebufferManager from "../Renderer/FramebufferManager.js";
+import ClearCommand from "../Renderer/ClearCommand.js";
+
+/**
+ * Creates and manages a framebuffer for the planar fill feature-ID pre-pass.
+ *
+ * During this pass, non-behind planar fill geometry writes its per-fragment
+ * feature ID into a screen-sized texture. Later, primitives with
+ * <code>behind: true</code> (BENTLEY_materials_planar_fill) sample this
+ * texture to check whether the pixel they are about to overwrite belongs to
+ * the same logical object (same feature ID). Only then do they apply an
+ * additional depth offset, pushing the fill behind its own object's edges
+ * and non-behind fills — but NOT behind other objects.
+ *
+ * Layout:
+ *   Color attachment 0 – R32F (single RED channel): encoded feature ID.
+ *   Depth-stencil attachment – shared with the main scene for correct depth testing.
+ *
+ * @alias PlanarFillIdFramebuffer
+ * @constructor
+ * @private
+ */
+function PlanarFillIdFramebuffer() {
+  this._framebufferManager = new FramebufferManager({
+    colorAttachmentsLength: 1,
+    createColorAttachments: true,
+    depthStencil: true,
+    supportsDepthTexture: true,
+    color: true,
+  });
+
+  this._framebuffer = undefined;
+  this._idTexture = undefined;
+  this._depthStencilTexture = undefined;
+
+  this._clearCommand = new ClearCommand({
+    color: new Color(0.0, 0.0, 0.0, 0.0),
+    depth: 1.0,
+    stencil: 0,
+    owner: this,
+  });
+}
+
+Object.defineProperties(PlanarFillIdFramebuffer.prototype, {
+  /**
+   * Gets the underlying framebuffer.
+   * @memberof PlanarFillIdFramebuffer.prototype
+   * @type {Framebuffer}
+   * @readonly
+   */
+  framebuffer: {
+    get: function () {
+      return this._framebuffer;
+    },
+  },
+
+  /**
+   * Gets the feature-ID texture (color attachment 0).
+   * @memberof PlanarFillIdFramebuffer.prototype
+   * @type {Texture}
+   * @readonly
+   */
+  idTexture: {
+    get: function () {
+      return this._idTexture;
+    },
+  },
+
+  /**
+   * Gets the depth-stencil texture.
+   * @memberof PlanarFillIdFramebuffer.prototype
+   * @type {Texture}
+   * @readonly
+   */
+  depthStencilTexture: {
+    get: function () {
+      return this._depthStencilTexture;
+    },
+  },
+});
+
+/**
+ * Updates (creates / resizes) the framebuffer to match the viewport.
+ *
+ * @param {Context} context
+ * @param {BoundingRectangle} viewport
+ * @param {boolean} hdr
+ * @returns {boolean} <code>true</code> if the framebuffer was recreated.
+ */
+PlanarFillIdFramebuffer.prototype.update = function (context, viewport, hdr) {
+  const width = viewport.width;
+  const height = viewport.height;
+
+  // Feature IDs are integers, so a 32-bit float channel provides plenty of range
+  // for feature IDs. A single RED channel (R32F) is used since only one value is
+  // stored per pixel. Rendering to R32F requires EXT_color_buffer_float, which is
+  // available in WebGL2 on all browsers CesiumJS supports; the UNSIGNED_BYTE fallback
+  // below only exists for stubbed WebGL contexts possibly used in tests.
+  const pixelDatatype = context.colorBufferFloat
+    ? PixelDatatype.FLOAT
+    : PixelDatatype.UNSIGNED_BYTE;
+
+  const changed = this._framebufferManager.update(
+    context,
+    width,
+    height,
+    1, // no MSAA
+    pixelDatatype,
+    PixelFormat.RED,
+  );
+
+  if (this._framebufferManager.framebuffer) {
+    this._framebuffer = this._framebufferManager.framebuffer;
+    this._idTexture = this._framebufferManager.getColorTexture(0);
+    this._depthStencilTexture =
+      this._framebufferManager.getDepthStencilTexture();
+  }
+
+  return changed;
+};
+
+/**
+ * Returns a ClearCommand that targets this framebuffer.
+ *
+ * @param {Color} [clearColor] Override the clear color (default: transparent black).
+ * @returns {ClearCommand}
+ */
+PlanarFillIdFramebuffer.prototype.getClearCommand = function (clearColor) {
+  this._clearCommand.framebuffer = this._framebuffer;
+  if (defined(clearColor)) {
+    Color.clone(clearColor, this._clearCommand.color);
+  }
+  return this._clearCommand;
+};
+
+/**
+ * Releases GPU resources without destroying this object; a later call to
+ * {@link PlanarFillIdFramebuffer#update} recreates them.
+ */
+PlanarFillIdFramebuffer.prototype.releaseResources = function () {
+  if (!defined(this._framebuffer)) {
+    return;
+  }
+  this._framebufferManager.destroy();
+  this._framebuffer = undefined;
+  this._idTexture = undefined;
+  this._depthStencilTexture = undefined;
+};
+
+/**
+ * @returns {boolean}
+ */
+PlanarFillIdFramebuffer.prototype.isDestroyed = function () {
+  return false;
+};
+
+/**
+ * Destroys WebGL resources.
+ */
+PlanarFillIdFramebuffer.prototype.destroy = function () {
+  this._framebufferManager =
+    this._framebufferManager && this._framebufferManager.destroy();
+  this._clearCommand = undefined;
+  return destroyObject(this);
+};
+
+export default PlanarFillIdFramebuffer;

package/Source/Scene/PntsParser.js

@@ -105,7 +105,6 @@ PntsParser.parse = function (arrayBuffer, byteOffset) {
       );
       // Copy the batchTableBinary section and let the underlying ArrayBuffer be freed
       batchTableBinary = new Uint8Array(batchTableBinary);
-      byteOffset += batchTableBinaryByteLength;
     }
   }
 
@@ -214,6 +213,7 @@ PntsParser.parse = function (arrayBuffer, byteOffset) {
  * a one-time warning will be printed.
  *
  * @param {object} parsedContent The parsed content
+ * @ignore
  */
 function removeInvalidBinaryBodyReferences(parsedContent) {
   const batchTableJson = parsedContent.batchTableJson;

package/Source/Scene/Polyline.js

@@ -34,6 +34,20 @@ import Material from "./Material.js";
  * @see PolylineCollection
  *
  */
+function makePolylineSegments(polyline, modelMatrix, columbusRepeatWorlds) {
+  if (columbusRepeatWorlds) {
+    // Columbus repeat worlds: keep the polyline continuous through the
+    // ±180° meridian instead of splitting it at the IDL.
+    // PolylineCollection's getSegments lifts the projected positions onto
+    // adjacent world copies so the line draws through the seam.
+    return {
+      positions: polyline._actualPositions,
+      lengths: [polyline._actualPositions.length],
+    };
+  }
+  return PolylinePipeline.wrapLongitude(polyline._actualPositions, modelMatrix);
+}
+
 function Polyline(options, polylineCollection) {
   options = options ?? Frozen.EMPTY_OBJECT;
 
@@ -76,9 +90,13 @@ function Polyline(options, polylineCollection) {
   }
 
   this._modelMatrix = modelMatrix;
-  this._segments = PolylinePipeline.wrapLongitude(
-    this._actualPositions,
+  this._columbusRepeatWorlds =
+    defined(polylineCollection) &&
+    polylineCollection._columbusRepeatWorlds === true;
+  this._segments = makePolylineSegments(
+    this,
     modelMatrix,
+    this._columbusRepeatWorlds,
   );
 
   this._actualLength = undefined;
@@ -371,10 +389,19 @@ Polyline.prototype.update = function () {
   const positionsChanged =
     this._propertiesChanged[POSITION_INDEX] > 0 ||
     this._propertiesChanged[POSITION_SIZE_INDEX] > 0;
-  if (!Matrix4.equals(modelMatrix, this._modelMatrix) || positionsChanged) {
-    this._segments = PolylinePipeline.wrapLongitude(
-      this._actualPositions,
+  const columbusRepeatWorlds =
+    defined(this._polylineCollection) &&
+    this._polylineCollection._columbusRepeatWorlds === true;
+  if (
+    !Matrix4.equals(modelMatrix, this._modelMatrix) ||
+    positionsChanged ||
+    columbusRepeatWorlds !== this._columbusRepeatWorlds
+  ) {
+    this._columbusRepeatWorlds = columbusRepeatWorlds;
+    this._segments = makePolylineSegments(
+      this,
       modelMatrix,
+      columbusRepeatWorlds,
     );
     this._boundingVolumeWC = BoundingSphere.transform(
       this._boundingVolume,

package/Source/Scene/PolylineCollection.js

@@ -32,6 +32,7 @@ import PolylineFS from "../Shaders/PolylineFS.js";
 import PolylineVS from "../Shaders/PolylineVS.js";
 import BatchTable from "./BatchTable.js";
 import BlendingState from "./BlendingState.js";
+import ColumbusWorlds from "./ColumbusWorlds.js";
 import Material from "./Material.js";
 import Polyline from "./Polyline.js";
 import SceneMode from "./SceneMode.js";
@@ -168,6 +169,11 @@ function PolylineCollection(options) {
 
   this._mode = undefined;
 
+  // Whether Columbus repeat worlds are enabled; when true, polylines are
+  // kept continuous through the ±180° meridian instead of being split at the
+  // IDL. Set each update() from the frame state.
+  this._columbusRepeatWorlds = false;
+
   this._polylinesToUpdate = [];
   this._vertexArrays = [];
   this._positionBuffer = undefined;
@@ -423,6 +429,17 @@ PolylineCollection.prototype.update = function (frameState) {
 
   updateMode(this, frameState);
 
+  const columbusRepeatWorlds =
+    frameState.columbusRepeatWorlds === true &&
+    (frameState.mode === SceneMode.SCENE2D ||
+      frameState.mode === SceneMode.COLUMBUS_VIEW);
+  if (this._columbusRepeatWorlds !== columbusRepeatWorlds) {
+    // Toggling repeat worlds changes whether polylines are split at the IDL,
+    // which changes vertex buffer sizes; rebuild the vertex arrays.
+    this._columbusRepeatWorlds = columbusRepeatWorlds;
+    this._createVertexArray = true;
+  }
+
   const context = frameState.context;
   const projection = frameState.mapProjection;
   let polyline;
@@ -1784,6 +1801,28 @@ PolylineBucket.prototype.getSegments = function (polyline, projection) {
     );
   }
 
+  if (
+    newPositions.length > 0 &&
+    (this.mode === SceneMode.SCENE2D ||
+      this.mode === SceneMode.COLUMBUS_VIEW) &&
+    polyline._polylineCollection._columbusRepeatWorlds === true
+  ) {
+    // Repeat worlds: the IDL split is disabled in this mode, so lift
+    // consecutive projected u values onto the same world copy. The line stays
+    // in the primary world; the scene renders the visible world copies by
+    // shifting the camera, so a line crossing the seam needs no per-copy
+    // placement of its own.
+    const worldWidth = ColumbusWorlds.getWorldWidth(projection);
+    for (let n = 1; n < newPositions.length; ++n) {
+      const du = newPositions[n].x - newPositions[n - 1].x;
+      if (du > worldWidth * 0.5) {
+        newPositions[n].x -= worldWidth;
+      } else if (du < -worldWidth * 0.5) {
+        newPositions[n].x += worldWidth;
+      }
+    }
+  }
+
   if (newPositions.length > 0) {
     polyline._boundingVolume2D = BoundingSphere.fromPoints(
       newPositions,

package/Source/Scene/PostProcessStage.js

@@ -640,8 +640,10 @@ function createStageOutputTextureFunction(stage, name) {
 function updateUniformTextures(stage, context) {
   const texturesToRelease = stage._texturesToRelease;
   for (let i = 0; i < texturesToRelease.length; ++i) {
-    let texture = texturesToRelease[i];
-    texture = texture && texture.destroy();
+    const texture = texturesToRelease[i];
+    if (defined(texture)) {
+      texture.destroy();
+    }
   }
   texturesToRelease.length = 0;
 

package/Source/Scene/Primitive.js

@@ -683,18 +683,20 @@ function createBatchTable(primitive, context) {
   primitive._batchTableOffsetAttribute2DIndex = offset2DIndex;
 }
 
-function cloneAttribute(attribute) {
-  let clonedValues;
-  if (Array.isArray(attribute.values)) {
-    clonedValues = attribute.values.slice(0);
-  } else {
-    clonedValues = new attribute.values.constructor(attribute.values);
+function cloneValues(values) {
+  if (Array.isArray(values)) {
+    return values.slice(0);
   }
+  const ValuesConstructor = values.constructor;
+  return new ValuesConstructor(values);
+}
+
+function cloneAttribute(attribute) {
   return new GeometryAttribute({
     componentDatatype: attribute.componentDatatype,
     componentsPerAttribute: attribute.componentsPerAttribute,
     normalize: attribute.normalize,
-    values: clonedValues,
+    values: cloneValues(attribute.values),
   });
 }
 
@@ -709,12 +711,7 @@ function cloneGeometry(geometry) {
 
   let indices;
   if (defined(geometry.indices)) {
-    const sourceValues = geometry.indices;
-    if (Array.isArray(sourceValues)) {
-      indices = sourceValues.slice(0);
-    } else {
-      indices = new sourceValues.constructor(sourceValues);
-    }
+    indices = cloneValues(geometry.indices);
   }
 
   return new Geometry({
@@ -1278,6 +1275,7 @@ function loadAsynchronous(primitive, frameState) {
           projection: projection,
           elementIndexUintSupported: frameState.context.elementIndexUint,
           scene3DOnly: scene3DOnly,
+          columbusRepeatWorlds: frameState.columbusRepeatWorlds === true,
           vertexCacheOptimize: primitive.vertexCacheOptimize,
           compressVertices: primitive.compressVertices,
           modelMatrix: primitive.modelMatrix,
@@ -1360,6 +1358,7 @@ function loadSynchronous(primitive, frameState) {
     projection: projection,
     elementIndexUintSupported: frameState.context.elementIndexUint,
     scene3DOnly: scene3DOnly,
+    columbusRepeatWorlds: frameState.columbusRepeatWorlds === true,
     vertexCacheOptimize: primitive.vertexCacheOptimize,
     compressVertices: primitive.compressVertices,
     modelMatrix: primitive.modelMatrix,