@hztxi/cesium-engine 25.0.7 → 26.2.2

package/Source/Scene/Snapping.js

@@ -0,0 +1,184 @@
+import BoundingRectangle from "../Core/BoundingRectangle.js";
+import Cartesian2 from "../Core/Cartesian2.js";
+import Cartesian3 from "../Core/Cartesian3.js";
+import Check from "../Core/Check.js";
+import defined from "../Core/defined.js";
+import oneTimeWarning from "../Core/oneTimeWarning.js";
+import Ray from "../Core/Ray.js";
+import { pickBegin, pickEnd } from "./Picking.js";
+import SnapFramebuffer from "./SnapFramebuffer.js";
+
+/**
+ * Implementation of {@link Scene#snap}: snap-to-geometry picking.
+ *
+ * A snapping pass is an offscreen pick render (it reuses the pick render
+ * machinery via <code>pickBegin</code>/<code>pickEnd</code>) that targets a
+ * dedicated RGBA32F framebuffer instead of the RGBA8 pick framebuffer. Each
+ * pixel carries a fuller payload than a pick color:
+ * <ul>
+ *   <li>R: pick ID (uint32)</li>
+ *   <li>G: isEdge flag (0.0/1.0)</li>
+ *   <li>B: linear eye-space depth (meters)</li>
+ *   <li>A: unused</li>
+ * </ul>
+ * The payload expression is built in PickingPipelineStage (DrawCommand.snapId)
+ * and compiled into a snap-derived shader by
+ * DerivedCommand.createSnapDerivedCommand. Only commands with a
+ * <code>snapId</code> (i.e. Model-pipeline primitives) render during a
+ * snapping pass.
+ *
+ * @namespace Snapping
+ *
+ * @private
+ */
+const Snapping = {};
+
+const scratchRectangle = new BoundingRectangle(0.0, 0.0, 3.0, 3.0);
+const scratchSnapCoord = new Cartesian2();
+const scratchSnapRay = new Ray();
+const scratchSnapOffset = new Cartesian3();
+
+// Radius around the crosshair, in pixels, used to sample the nearest surface
+// (the occluder the cursor is on).
+const SNAP_OCCLUDER_RADIUS_PIXELS = 3.0;
+
+// An edge more than this fraction deeper than that surface is treated as
+// occluded by it (the edge is only visible because it pokes through a gap in a
+// nearer silhouette), so snap doesn't punch through to geometry behind the
+// object the cursor is on.
+const SNAP_OCCLUSION_TOLERANCE = 0.1;
+
+function cursorDist(hit) {
+  return Math.sqrt(hit.x * hit.x + hit.y * hit.y);
+}
+
+function selectBestHit(hits) {
+  // Depth of the nearest surface under the crosshair; edges well behind it are
+  // occluded by the object the cursor is on and must not win.
+  let occluderDepth = Number.POSITIVE_INFINITY;
+  for (const hit of hits) {
+    if (!hit.isEdge && cursorDist(hit) <= SNAP_OCCLUDER_RADIUS_PIXELS) {
+      occluderDepth = Math.min(occluderDepth, hit.depth);
+    }
+  }
+  const maxEdgeDepth = occluderDepth * (1.0 + SNAP_OCCLUSION_TOLERANCE);
+
+  // Edges outrank surfaces, but only edges in front of (or at) the occluder;
+  // otherwise fall back to the closest surface. Within the chosen group the
+  // hit closest to the crosshair wins.
+  const visible = hits.filter(
+    (hit) => !hit.isEdge || hit.depth <= maxEdgeDepth,
+  );
+  const wantEdge = visible.some((hit) => hit.isEdge);
+  const group = visible.filter((hit) => hit.isEdge === wantEdge);
+  return group.reduce((best, hit) =>
+    cursorDist(hit) < cursorDist(best) ? hit : best,
+  );
+}
+
+// Unproject a snap hit's eye-space depth (channel B of the snap framebuffer,
+// written by the snap shader at the edge fragment itself) into a world
+// position.
+function snapHitToWorld(scene, windowPosition, hit) {
+  const coords = scratchSnapCoord;
+  coords.x = windowPosition.x + hit.x;
+  coords.y = windowPosition.y + hit.y;
+
+  const ray = scene.camera.getPickRay(coords, scratchSnapRay);
+  if (!defined(ray)) {
+    return undefined;
+  }
+
+  // hit.depth is perpendicular distance from the camera plane along the view
+  // direction; convert to distance along the (non-axis-aligned) pick ray.
+  const cos = Cartesian3.dot(ray.direction, scene.camera.directionWC);
+  if (cos <= 0.0) {
+    return undefined;
+  }
+  const t = hit.depth / cos;
+
+  const offset = Cartesian3.multiplyByScalar(
+    ray.direction,
+    t,
+    scratchSnapOffset,
+  );
+  return Cartesian3.add(ray.origin, offset, new Cartesian3());
+}
+
+/**
+ * Returns the best snap target in a screen-space region around
+ * <code>windowPosition</code>. See {@link Scene#snap} for the public API.
+ *
+ * @param {Scene} scene
+ * @param {Cartesian2} windowPosition Window coordinates at the center of the search region.
+ * @param {object} [options] Object with the following properties:
+ * @param {number} [options.width=25] Width of the search region in pixels.
+ * @param {number} [options.height=options.width] Height of the search region in pixels.
+ * @returns {SceneSnapResult | undefined}
+ *
+ * @private
+ */
+Snapping.snap = function (scene, windowPosition, options) {
+  //>>includeStart('debug', pragmas.debug);
+  Check.defined("windowPosition", windowPosition);
+  //>>includeEnd('debug');
+
+  const width = options?.width ?? 25;
+  const height = options?.height ?? width;
+
+  const { context, defaultView } = scene;
+
+  // The snap framebuffer is RGBA32F; rendering to it requires float color
+  // attachment support.
+  if (!context.colorBufferFloat) {
+    oneTimeWarning(
+      "snap-color-buffer-float",
+      "Scene.snap requires the EXT_color_buffer_float extension, which is not supported on this platform.",
+    );
+    return undefined;
+  }
+
+  // Created lazily so applications that never snap pay no framebuffer cost.
+  if (!defined(defaultView.snapFramebuffer)) {
+    defaultView.snapFramebuffer = new SnapFramebuffer(context);
+  }
+  const snapFramebuffer = defaultView.snapFramebuffer;
+
+  const drawingBufferRectangle = scratchRectangle;
+  pickBegin(scene, windowPosition, drawingBufferRectangle, width, height, {
+    framebuffer: snapFramebuffer,
+    snap: true,
+  });
+  const hits = snapFramebuffer.end(drawingBufferRectangle);
+  pickEnd(scene);
+
+  if (hits.length === 0) {
+    return undefined;
+  }
+
+  const best = selectBestHit(hits);
+  if (!defined(best)) {
+    return undefined;
+  }
+
+  const position = snapHitToWorld(scene, windowPosition, best);
+  if (!defined(position)) {
+    return undefined;
+  }
+
+  return {
+    object: best.object,
+    isEdge: best.isEdge,
+    position: position,
+    screenPosition: new Cartesian2(
+      windowPosition.x + best.x,
+      windowPosition.y + best.y,
+    ),
+  };
+};
+
+// Exposed for testing.
+Snapping._selectBestHit = selectBestHit;
+Snapping._snapHitToWorld = snapHitToWorld;
+
+export default Snapping;

package/Source/Scene/TerrainFillMesh.js

@@ -823,6 +823,7 @@ function createFillMesh(tileProvider, frameState, tile, vertexArraysToDestroy) {
   GlobeSurfaceTile.initialize(
     tile,
     tileProvider.terrainProvider,
+    tileProvider.vectorProvider,
     tileProvider._imageryLayers,
   );
 
@@ -1243,7 +1244,7 @@ function createFillMesh(tileProvider, frameState, tile, vertexArraysToDestroy) {
 
     indices[indexOut++] = centerIndex;
     indices[indexOut++] = i;
-    indices[indexOut++] = 0;
+    indices[indexOut] = 0;
 
     const westIndicesSouthToNorth = [];
     for (i = southwestIndex; i >= northwestIndex; --i) {
@@ -1800,7 +1801,7 @@ function addEdgeMesh(
   heightRange,
 ) {
   // Handle copying edges across the anti-meridian.
-  let sourceRectangle = edgeTile.rectangle;
+  let sourceRectangle;
   if (tileEdge === TileEdge.EAST && terrainFillMesh.tile.x === 0) {
     sourceRectangle = Rectangle.clone(
       edgeTile.rectangle,

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;