@hztxi/cesium-engine 25.0.6 → 26.2.1

package/Source/Scene/Geometry3DTileContent.js

@@ -13,147 +13,172 @@ import Vector3DTileGeometry from "./Vector3DTileGeometry.js";
  * Implements the {@link Cesium3DTileContent} interface.
  * </p>
  *
- * @alias Geometry3DTileContent
- * @constructor
- *
+ * @implements Cesium3DTileContent
  * @private
  */
-function Geometry3DTileContent(
-  tileset,
-  tile,
-  resource,
-  arrayBuffer,
-  byteOffset,
-) {
-  this._tileset = tileset;
-  this._tile = tile;
-  this._resource = resource;
-  this._geometries = undefined;
-
-  this._metadata = undefined;
-
-  this._batchTable = undefined;
-  this._features = undefined;
+class Geometry3DTileContent {
+  constructor(tileset, tile, resource, arrayBuffer, byteOffset) {
+    this._tileset = tileset;
+    this._tile = tile;
+    this._resource = resource;
+    this._geometries = undefined;
 
-  /**
-   * Part of the {@link Cesium3DTileContent} interface.
-   */
-  this.featurePropertiesDirty = false;
-  this._group = undefined;
+    this._metadata = undefined;
 
-  this._ready = false;
+    this._batchTable = undefined;
+    this._features = undefined;
 
-  initialize(this, arrayBuffer, byteOffset);
-}
+    /**
+     * Part of the {@link Cesium3DTileContent} interface.
+     */
+    this.featurePropertiesDirty = false;
+    this._group = undefined;
 
-Object.defineProperties(Geometry3DTileContent.prototype, {
-  featuresLength: {
-    get: function () {
-      return defined(this._batchTable) ? this._batchTable.featuresLength : 0;
-    },
-  },
-
-  pointsLength: {
-    get: function () {
-      return 0;
-    },
-  },
-
-  trianglesLength: {
-    get: function () {
-      if (defined(this._geometries)) {
-        return this._geometries.trianglesLength;
-      }
-      return 0;
-    },
-  },
-
-  geometryByteLength: {
-    get: function () {
-      if (defined(this._geometries)) {
-        return this._geometries.geometryByteLength;
-      }
-      return 0;
-    },
-  },
-
-  texturesByteLength: {
-    get: function () {
-      return 0;
-    },
-  },
-
-  batchTableByteLength: {
-    get: function () {
-      return defined(this._batchTable)
-        ? this._batchTable.batchTableByteLength
-        : 0;
-    },
-  },
-
-  innerContents: {
-    get: function () {
-      return undefined;
-    },
-  },
+    this._ready = false;
+
+    initialize(this, arrayBuffer, byteOffset);
+  }
+
+  get featuresLength() {
+    return defined(this._batchTable) ? this._batchTable.featuresLength : 0;
+  }
+
+  get pointsLength() {
+    return 0;
+  }
+
+  get trianglesLength() {
+    if (defined(this._geometries)) {
+      return this._geometries.trianglesLength;
+    }
+    return 0;
+  }
+
+  get geometryByteLength() {
+    if (defined(this._geometries)) {
+      return this._geometries.geometryByteLength;
+    }
+    return 0;
+  }
+
+  get texturesByteLength() {
+    return 0;
+  }
+
+  get batchTableByteLength() {
+    return defined(this._batchTable)
+      ? this._batchTable.batchTableByteLength
+      : 0;
+  }
+
+  get innerContents() {
+    return undefined;
+  }
 
   /**
    * Returns true when the tile's content is ready to render; otherwise false
    *
-   * @memberof Geometry3DTileContent.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);
-    },
-  },
-
-  metadata: {
-    get: function () {
-      return this._metadata;
-    },
-    set: function (value) {
-      this._metadata = value;
-    },
-  },
-
-  batchTable: {
-    get: function () {
-      return this._batchTable;
-    },
-  },
-
-  group: {
-    get: function () {
-      return this._group;
-    },
-    set: function (value) {
-      this._group = value;
-    },
-  },
-});
+  get ready() {
+    return this._ready;
+  }
+
+  get tileset() {
+    return this._tileset;
+  }
+
+  get tile() {
+    return this._tile;
+  }
+
+  get url() {
+    return this._resource.getUrlComponent(true);
+  }
+
+  get metadata() {
+    return this._metadata;
+  }
+
+  set metadata(value) {
+    this._metadata = value;
+  }
+
+  get batchTable() {
+    return this._batchTable;
+  }
+
+  get group() {
+    return this._group;
+  }
+
+  set group(value) {
+    this._group = value;
+  }
+
+  hasProperty(batchId, name) {
+    return this._batchTable.hasProperty(batchId, name);
+  }
+
+  getFeature(batchId) {
+    //>>includeStart('debug', pragmas.debug);
+    const featuresLength = this.featuresLength;
+    if (!defined(batchId) || batchId < 0 || batchId >= featuresLength) {
+      throw new DeveloperError(
+        `batchId is required and between zero and featuresLength - 1 (${
+          featuresLength - 1
+        }).`,
+      );
+    }
+    //>>includeEnd('debug');
+
+    createFeatures(this);
+    return this._features[batchId];
+  }
+
+  applyDebugSettings(enabled, color) {
+    if (defined(this._geometries)) {
+      this._geometries.applyDebugSettings(enabled, color);
+    }
+  }
+
+  applyStyle(style) {
+    createFeatures(this);
+    if (defined(this._geometries)) {
+      this._geometries.applyStyle(style, this._features);
+    }
+  }
+
+  update(tileset, frameState) {
+    if (defined(this._geometries)) {
+      this._geometries.classificationType = this._tileset.classificationType;
+      this._geometries.debugWireframe = this._tileset.debugWireframe;
+      this._geometries.update(frameState);
+    }
+
+    if (defined(this._batchTable) && this._geometries.ready) {
+      this._batchTable.update(tileset, frameState);
+      this._ready = true;
+    }
+  }
+
+  pick(ray, frameState, result) {
+    return undefined;
+  }
+
+  isDestroyed() {
+    return false;
+  }
+
+  destroy() {
+    this._geometries = this._geometries && this._geometries.destroy();
+    this._batchTable = this._batchTable && this._batchTable.destroy();
+    return destroyObject(this);
+  }
+}
 
 function createColorChangedCallback(content) {
   return function (batchId, color) {
@@ -472,63 +497,4 @@ function createFeatures(content) {
   }
 }
 
-Geometry3DTileContent.prototype.hasProperty = function (batchId, name) {
-  return this._batchTable.hasProperty(batchId, name);
-};
-
-Geometry3DTileContent.prototype.getFeature = function (batchId) {
-  //>>includeStart('debug', pragmas.debug);
-  const featuresLength = this.featuresLength;
-  if (!defined(batchId) || batchId < 0 || batchId >= featuresLength) {
-    throw new DeveloperError(
-      `batchId is required and between zero and featuresLength - 1 (${
-        featuresLength - 1
-      }).`,
-    );
-  }
-  //>>includeEnd('debug');
-
-  createFeatures(this);
-  return this._features[batchId];
-};
-
-Geometry3DTileContent.prototype.applyDebugSettings = function (enabled, color) {
-  if (defined(this._geometries)) {
-    this._geometries.applyDebugSettings(enabled, color);
-  }
-};
-
-Geometry3DTileContent.prototype.applyStyle = function (style) {
-  createFeatures(this);
-  if (defined(this._geometries)) {
-    this._geometries.applyStyle(style, this._features);
-  }
-};
-
-Geometry3DTileContent.prototype.update = function (tileset, frameState) {
-  if (defined(this._geometries)) {
-    this._geometries.classificationType = this._tileset.classificationType;
-    this._geometries.debugWireframe = this._tileset.debugWireframe;
-    this._geometries.update(frameState);
-  }
-
-  if (defined(this._batchTable) && this._geometries.ready) {
-    this._batchTable.update(tileset, frameState);
-    this._ready = true;
-  }
-};
-
-Geometry3DTileContent.prototype.pick = function (ray, frameState, result) {
-  return undefined;
-};
-
-Geometry3DTileContent.prototype.isDestroyed = function () {
-  return false;
-};
-
-Geometry3DTileContent.prototype.destroy = function () {
-  this._geometries = this._geometries && this._geometries.destroy();
-  this._batchTable = this._batchTable && this._batchTable.destroy();
-  return destroyObject(this);
-};
 export default Geometry3DTileContent;

package/Source/Scene/Globe.js

@@ -20,6 +20,7 @@ import GlobeFS from "../Shaders/GlobeFS.js";
 import GlobeVS from "../Shaders/GlobeVS.js";
 import AtmosphereCommon from "../Shaders/AtmosphereCommon.js";
 import GroundAtmosphere from "../Shaders/GroundAtmosphere.js";
+import ColumbusWorlds from "./ColumbusWorlds.js";
 import GlobeSurfaceShaderSet from "./GlobeSurfaceShaderSet.js";
 import GlobeSurfaceTileProvider from "./GlobeSurfaceTileProvider.js";
 import GlobeTranslucency from "./GlobeTranslucency.js";
@@ -28,6 +29,7 @@ import QuadtreePrimitive from "./QuadtreePrimitive.js";
 import SceneMode from "./SceneMode.js";
 import ShadowMode from "./ShadowMode.js";
 import CesiumMath from "../Core/Math.js";
+import VectorProvider from "../Core/VectorProvider.js";
 
 /**
  * The globe rendered in the scene, including its terrain ({@link Globe#terrainProvider})
@@ -45,6 +47,9 @@ function Globe(ellipsoid) {
     ellipsoid: ellipsoid,
   });
   const imageryLayerCollection = new ImageryLayerCollection();
+  const vectorProvider = new VectorProvider({
+    tilingScheme: terrainProvider.tilingScheme,
+  });
 
   this._ellipsoid = ellipsoid;
   this._imageryLayerCollection = imageryLayerCollection;
@@ -57,12 +62,15 @@ function Globe(ellipsoid) {
       terrainProvider: terrainProvider,
       imageryLayers: imageryLayerCollection,
       surfaceShaderSet: this._surfaceShaderSet,
+      vectorProvider,
     }),
   });
 
   this._terrainProvider = terrainProvider;
   this._terrainProviderChanged = new Event();
 
+  this._vectorProvider = vectorProvider;
+
   this._undergroundColor = Color.clone(Color.BLACK);
   this._undergroundColorAlphaByDistance = new NearFarScalar(
     ellipsoid.maximumRadius / 1000.0,
@@ -569,6 +577,9 @@ Object.defineProperties(Globe.prototype, {
     set: function (value) {
       if (value !== this._terrainProvider) {
         this._terrainProvider = value;
+        if (defined(value)) {
+          this._vectorProvider.tilingScheme = value.tilingScheme;
+        }
         this._terrainProviderChanged.raiseEvent(value);
         if (defined(this._material)) {
           makeShadersDirty(this);
@@ -588,6 +599,16 @@ Object.defineProperties(Globe.prototype, {
       return this._terrainProviderChanged;
     },
   },
+  /**
+   * @memberof Globe.prototype
+   * @type {VectorProvider}
+   * @ignore
+   */
+  vectorProvider: {
+    get: function () {
+      return this._vectorProvider;
+    },
+  },
   /**
    * Gets an event that's raised when the length of the tile load queue has changed since the last render frame.  When the load queue is empty,
    * all terrain and imagery for the current view have been loaded.  The event passes the new length of the tile load queue.
@@ -724,24 +745,28 @@ function makeShadersDirty(globe) {
 
 function createComparePickTileFunction(rayOrigin) {
   return function (a, b) {
-    const aDist = BoundingSphere.distanceSquaredTo(
-      a.pickBoundingSphere,
-      rayOrigin,
-    );
-    const bDist = BoundingSphere.distanceSquaredTo(
-      b.pickBoundingSphere,
-      rayOrigin,
-    );
+    const aDist = BoundingSphere.distanceSquaredTo(a.sphere, rayOrigin);
+    const bDist = BoundingSphere.distanceSquaredTo(b.sphere, rayOrigin);
 
     return aDist - bDist;
   };
 }
 
+// Columbus repeat worlds: how many translated world copies to test on either
+// side of the pick ray's own world when repeat worlds are enabled.
+const GLOBE_COLUMBUS_MAX_EXTRA_WORLDS = 2;
+
+function getGlobeColumbusWorldWidth(projection) {
+  return ColumbusWorlds.getWorldWidth(projection);
+}
+
 const scratchArray = [];
 const scratchSphereIntersectionResult = {
   start: 0.0,
   stop: 0.0,
 };
+const scratchPickOffsetSphere = new BoundingSphere();
+const scratchColumbusPickRay = new Ray();
 
 /**
  * Find an intersection between a ray and the globe surface that was rendered. The ray must be given in world coordinates.
@@ -774,6 +799,13 @@ Globe.prototype.pickWorldCoordinates = function (
   const mode = scene.mode;
   const projection = scene.mapProjection;
 
+  const repeatWorlds =
+    scene.columbusRepeatWorlds === true &&
+    (mode === SceneMode.SCENE2D || mode === SceneMode.COLUMBUS_VIEW);
+  const worldWidth = repeatWorlds
+    ? getGlobeColumbusWorldWidth(projection)
+    : 0.0;
+
   const sphereIntersections = scratchArray;
   sphereIntersections.length = 0;
 
@@ -810,13 +842,48 @@ Globe.prototype.pickWorldCoordinates = function (
       continue;
     }
 
-    const boundingSphereIntersection = IntersectionTests.raySphere(
-      ray,
-      boundingVolume,
-      scratchSphereIntersectionResult,
-    );
-    if (defined(boundingSphereIntersection)) {
-      sphereIntersections.push(surfaceTile);
+    if (!repeatWorlds) {
+      const boundingSphereIntersection = IntersectionTests.raySphere(
+        ray,
+        boundingVolume,
+        scratchSphereIntersectionResult,
+      );
+      if (defined(boundingSphereIntersection)) {
+        sphereIntersections.push({
+          surfaceTile,
+          sphere: boundingVolume,
+          offset: 0.0,
+        });
+      }
+      continue;
+    }
+
+    // Columbus repeat worlds: a translated copy of this tile may be hit even
+    // when the primary sphere is not. Test the copies around the ray's own
+    // world so points beyond the ±180° meridian pick correctly.
+    const rayWorld = Math.round(ray.origin.y / worldWidth);
+    for (
+      let w = rayWorld - GLOBE_COLUMBUS_MAX_EXTRA_WORLDS;
+      w <= rayWorld + GLOBE_COLUMBUS_MAX_EXTRA_WORLDS;
+      ++w
+    ) {
+      const offset = w * worldWidth;
+      const offsetSphere = scratchPickOffsetSphere;
+      Cartesian3.clone(boundingVolume.center, offsetSphere.center);
+      offsetSphere.center.y += offset;
+      offsetSphere.radius = boundingVolume.radius;
+      const boundingSphereIntersection = IntersectionTests.raySphere(
+        ray,
+        offsetSphere,
+        scratchSphereIntersectionResult,
+      );
+      if (defined(boundingSphereIntersection)) {
+        sphereIntersections.push({
+          surfaceTile,
+          sphere: BoundingSphere.clone(offsetSphere, new BoundingSphere()),
+          offset,
+        });
+      }
     }
   }
 
@@ -825,13 +892,34 @@ Globe.prototype.pickWorldCoordinates = function (
   let intersection;
   const length = sphereIntersections.length;
   for (let i = 0; i < length; ++i) {
-    intersection = sphereIntersections[i].pick(
-      ray,
-      scene.mode,
-      scene.mapProjection,
-      cullBackFaces,
-      result,
-    );
+    const candidate = sphereIntersections[i];
+    const offset = candidate.offset;
+    if (offset === 0.0) {
+      intersection = candidate.surfaceTile.pick(
+        ray,
+        scene.mode,
+        scene.mapProjection,
+        cullBackFaces,
+        result,
+      );
+    } else {
+      // Pick against the copy by shifting the ray into the primary world,
+      // then shifting the hit point back onto the copy.
+      const pickRay = scratchColumbusPickRay;
+      Cartesian3.clone(ray.origin, pickRay.origin);
+      pickRay.origin.y -= offset;
+      Cartesian3.clone(ray.direction, pickRay.direction);
+      intersection = candidate.surfaceTile.pick(
+        pickRay,
+        scene.mode,
+        scene.mapProjection,
+        cullBackFaces,
+        result,
+      );
+      if (defined(intersection)) {
+        intersection.y += offset;
+      }
+    }
     if (defined(intersection)) {
       break;
     }