@cesium/engine 25.0.0 → 26.1.0

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,
@@ -270,6 +271,7 @@ function computePickingDrawingBufferRectangle(
  * @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.
+ * @ignore
  */
 function pickBegin(
   scene,
@@ -332,6 +334,7 @@ function pickBegin(
  * Teardown needed after picking.
  *
  * @param {Scene} scene
+ * @ignore
  */
 function pickEnd(scene) {
   const { context } = scene;
@@ -808,6 +811,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 +879,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/PntsParser.js

@@ -214,6 +214,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/QuadtreePrimitive.js

@@ -1527,11 +1527,12 @@ function updateHeights(primitive, frameState) {
           );
 
           if (defined(position)) {
-            // Store the computed position in the cache for future reuse
+            // `pick` wrote into the module-level `scratchPosition`, so `position`
+            // aliases it — clone before caching or the next pick mutates every entry.
             tile.setPositionCacheEntry(
               data.positionCartographic,
               primitive.maximumScreenSpaceError,
-              position,
+              Cartesian3.clone(position),
             );
           }
         }

package/Source/Scene/ResourceCacheKey.js

@@ -3,8 +3,8 @@ import Frozen from "../Core/Frozen.js";
 import defined from "../Core/defined.js";
 import DeveloperError from "../Core/DeveloperError.js";
 import getAbsoluteUri from "../Core/getAbsoluteUri.js";
+import findMeshoptExtension from "./findMeshoptExtension.js";
 import GltfLoaderUtil from "./GltfLoaderUtil.js";
-import hasExtension from "./hasExtension.js";
 
 /**
  * Compute cache keys for resources in {@link ResourceCache}.
@@ -22,8 +22,8 @@ function getExternalResourceCacheKey(resource) {
 function getBufferViewCacheKey(bufferView) {
   let { byteOffset, byteLength } = bufferView;
 
-  if (hasExtension(bufferView, "EXT_meshopt_compression")) {
-    const meshopt = bufferView.extensions.EXT_meshopt_compression;
+  const meshopt = findMeshoptExtension(bufferView);
+  if (defined(meshopt)) {
     byteOffset = meshopt.byteOffset ?? 0;
     byteLength = meshopt.byteLength;
   }
@@ -247,8 +247,8 @@ ResourceCacheKey.getBufferViewCacheKey = function (options) {
   const bufferView = gltf.bufferViews[bufferViewId];
   let bufferId = bufferView.buffer;
   const buffer = gltf.buffers[bufferId];
-  if (hasExtension(bufferView, "EXT_meshopt_compression")) {
-    const meshopt = bufferView.extensions.EXT_meshopt_compression;
+  const meshopt = findMeshoptExtension(bufferView);
+  if (defined(meshopt)) {
     bufferId = meshopt.buffer;
   }
 

package/Source/Scene/Scene.js

@@ -2466,6 +2466,7 @@ function createWorkingFrustum(camera) {
  *
  * @param {Scene} scene The scene.
  * @returns {Function} A function to execute translucent commands.
+ * @ignore
  */
 function obtainTranslucentCommandExecutionFunction(scene) {
   if (scene._environmentState.useOIT) {
@@ -2618,6 +2619,29 @@ function performCesium3DTileEdgesPass(scene, passState, frustumCommands) {
   passState.framebuffer = originalFramebuffer;
 }
 
+/**
+ * Execute edge commands that should render directly to the main framebuffer
+ * (EDGES_ONLY mode). These edges bypass the MRT edge framebuffer and render
+ * on top of surface geometry.
+ *
+ * @param {Scene} scene
+ * @param {PassState} passState
+ * @param {FrustumCommands} frustumCommands
+ *
+ * @private
+ */
+function performCesium3DTileEdgesDirectPass(scene, passState, frustumCommands) {
+  scene.context.uniformState.updatePass(Pass.CESIUM_3D_TILE_EDGES_DIRECT);
+
+  const commands = frustumCommands.commands[Pass.CESIUM_3D_TILE_EDGES_DIRECT];
+  const commandCount =
+    frustumCommands.indices[Pass.CESIUM_3D_TILE_EDGES_DIRECT];
+
+  for (let j = 0; j < commandCount; ++j) {
+    executeCommand(commands[j], scene, passState);
+  }
+}
+
 /**
  * Execute the draw commands for all the render passes.
  *
@@ -2911,6 +2935,9 @@ function executeCommands(scene, passState) {
 
     performPass(frustumCommands, Pass.OPAQUE);
 
+    // Draw direct edges (EDGES_ONLY mode) after opaque surfaces
+    performCesium3DTileEdgesDirectPass(scene, passState, frustumCommands);
+
     performGaussianSplatPass(scene, passState, frustumCommands);
 
     if (index !== 0 && scene.mode !== SceneMode.SCENE2D) {

package/Source/Scene/Tileset3DTileContent.js

@@ -8,175 +8,142 @@ import destroyObject from "../Core/destroyObject.js";
  * Implements the {@link Cesium3DTileContent} interface.
  * </p>
  *
- * @alias Tileset3DTileContent
- * @constructor
- *
+ * @implements Cesium3DTileContent
  * @private
  */
-function Tileset3DTileContent(tileset, tile, resource) {
-  this._tileset = tileset;
-  this._tile = tile;
-  this._resource = resource;
+class Tileset3DTileContent {
+  constructor(tileset, tile, resource) {
+    this._tileset = tileset;
+    this._tile = tile;
+    this._resource = resource;
 
-  this.featurePropertiesDirty = false;
+    this.featurePropertiesDirty = false;
 
-  this._metadata = undefined;
-  this._group = undefined;
+    this._metadata = undefined;
+    this._group = undefined;
 
-  this._ready = false;
-}
+    this._ready = false;
+  }
+
+  get featuresLength() {
+    return 0;
+  }
+
+  get pointsLength() {
+    return 0;
+  }
+
+  get trianglesLength() {
+    return 0;
+  }
+
+  get geometryByteLength() {
+    return 0;
+  }
+
+  get texturesByteLength() {
+    return 0;
+  }
 
-Object.defineProperties(Tileset3DTileContent.prototype, {
-  featuresLength: {
-    get: function () {
-      return 0;
-    },
-  },
-
-  pointsLength: {
-    get: function () {
-      return 0;
-    },
-  },
-
-  trianglesLength: {
-    get: function () {
-      return 0;
-    },
-  },
-
-  geometryByteLength: {
-    get: function () {
-      return 0;
-    },
-  },
-
-  texturesByteLength: {
-    get: function () {
-      return 0;
-    },
-  },
-
-  batchTableByteLength: {
-    get: function () {
-      return 0;
-    },
-  },
-
-  innerContents: {
-    get: function () {
-      return undefined;
-    },
-  },
+  get batchTableByteLength() {
+    return 0;
+  }
+
+  get innerContents() {
+    return undefined;
+  }
 
   /**
    * Returns true when the tile's content is ready to render; otherwise false
    *
-   * @memberof Tileset3DTileContent.prototype
    *
    * @type {boolean}
    * @readonly
    * @private
    */
-  ready: {
-    get: function () {
-      return this._ready;
-    },
-  },
-
-  tileset: {
-    get: function () {
-      return this._tileset;
-    },
-  },
-
-  tile: {
-    get: function () {
-      return this._tile;
-    },
-  },
-
-  url: {
-    get: function () {
-      return this._resource.getUrlComponent(true);
-    },
-  },
-
-  batchTable: {
-    get: function () {
-      return undefined;
-    },
-  },
-
-  metadata: {
-    get: function () {
-      return this._metadata;
-    },
-    set: function (value) {
-      this._metadata = value;
-    },
-  },
-
-  group: {
-    get: function () {
-      return this._group;
-    },
-    set: function (value) {
-      this._group = value;
-    },
-  },
-});
+  get ready() {
+    return this._ready;
+  }
 
-/**
- * Creates an instance of Tileset3DTileContent from a parsed JSON object
- * @param {Cesium3DTileset} tileset
- * @param {Cesium3DTile} tile
- * @param {Resource} resource
- * @param {object} json
- * @returns {Tileset3DTileContent}
- */
-Tileset3DTileContent.fromJson = function (tileset, tile, resource, json) {
-  const content = new Tileset3DTileContent(tileset, tile, resource);
-  content._tileset.loadTileset(content._resource, json, content._tile);
-  content._ready = true;
+  get tileset() {
+    return this._tileset;
+  }
 
-  return content;
-};
+  get tile() {
+    return this._tile;
+  }
 
-/**
- * Part of the {@link Cesium3DTileContent} interface.  <code>Tileset3DTileContent</code>
- * always returns <code>false</code> since a tile of this type does not have any features.
- */
-Tileset3DTileContent.prototype.hasProperty = function (batchId, name) {
-  return false;
-};
+  get url() {
+    return this._resource.getUrlComponent(true);
+  }
 
-/**
- * Part of the {@link Cesium3DTileContent} interface.  <code>Tileset3DTileContent</code>
- * always returns <code>undefined</code> since a tile of this type does not have any features.
- */
-Tileset3DTileContent.prototype.getFeature = function (batchId) {
-  return undefined;
-};
+  get batchTable() {
+    return undefined;
+  }
 
-Tileset3DTileContent.prototype.applyDebugSettings = function (
-  enabled,
-  color,
-) {};
+  get metadata() {
+    return this._metadata;
+  }
 
-Tileset3DTileContent.prototype.applyStyle = function (style) {};
+  set metadata(value) {
+    this._metadata = value;
+  }
 
-Tileset3DTileContent.prototype.update = function (tileset, frameState) {};
+  get group() {
+    return this._group;
+  }
 
-Tileset3DTileContent.prototype.pick = function (ray, frameState, result) {
-  return undefined;
-};
+  set group(value) {
+    this._group = value;
+  }
 
-Tileset3DTileContent.prototype.isDestroyed = function () {
-  return false;
-};
+  /**
+   * Creates an instance of Tileset3DTileContent from a parsed JSON object
+   * @param {Cesium3DTileset} tileset
+   * @param {Cesium3DTile} tile
+   * @param {Resource} resource
+   * @param {object} json
+   * @returns {Tileset3DTileContent}
+   */
+  static fromJson(tileset, tile, resource, json) {
+    const content = new Tileset3DTileContent(tileset, tile, resource);
+    content._tileset.loadTileset(content._resource, json, content._tile);
+    content._ready = true;
+
+    return content;
+  }
+
+  /**
+   * Part of the {@link Cesium3DTileContent} interface.  <code>Tileset3DTileContent</code>
+   * always returns <code>false</code> since a tile of this type does not have any features.
+   */
+  hasProperty(batchId, name) {
+    return false;
+  }
+
+  /**
+   * Part of the {@link Cesium3DTileContent} interface.  <code>Tileset3DTileContent</code>
+   * always returns <code>undefined</code> since a tile of this type does not have any features.
+   */
+  getFeature(batchId) {
+    return undefined;
+  }
+
+  applyDebugSettings(enabled, color) {}
+  applyStyle(style) {}
+  update(tileset, frameState) {}
+
+  pick(ray, frameState, result) {
+    return undefined;
+  }
+
+  isDestroyed() {
+    return false;
+  }
+
+  destroy() {
+    return destroyObject(this);
+  }
+}
 
-Tileset3DTileContent.prototype.destroy = function () {
-  return destroyObject(this);
-};
 export default Tileset3DTileContent;