@hztxi/cesium-engine 25.0.4 → 25.0.7

package/Source/Core/PolylinePipeline.js

@@ -21,9 +21,16 @@ PolylinePipeline.numberOfPoints = function (p0, p1, minDistance) {
 };
 
 PolylinePipeline.numberOfPointsRhumbLine = function (p0, p1, granularity) {
+  // Wrap the longitude delta to (-pi, pi]: EllipsoidRhumbLine always
+  // interpolates along the shortest rhumb path. A segment crossing the
+  // +/-180 meridian has a raw delta of nearly 2*pi but spans only a tiny arc;
+  // counting subdivisions from the raw delta over-tessellates that segment by
+  // up to ~360x, which skews index-based parameterizations (the polyline `st`
+  // attribute used by line materials): animations appear to stall at the
+  // antimeridian.
+  const deltaLongitude = CesiumMath.negativePiToPi(p0.longitude - p1.longitude);
   const radiansDistanceSquared =
-    Math.pow(p0.longitude - p1.longitude, 2) +
-    Math.pow(p0.latitude - p1.latitude, 2);
+    Math.pow(deltaLongitude, 2) + Math.pow(p0.latitude - p1.latitude, 2);
 
   return Math.max(
     1,

package/Source/DataSources/PolylineGeometryUpdater.js

@@ -649,6 +649,8 @@ function DynamicGeometryUpdater(primitives, groundPrimitives, geometryUpdater) {
   this._primitives = primitives;
   this._groundPrimitives = groundPrimitives;
   this._groundPolylinePrimitive = undefined;
+  this._groundGeometrySignature = undefined;
+  this._colorAppearance = undefined;
   this._material = undefined;
   this._geometryUpdater = geometryUpdater;
   this._positions = [];
@@ -692,6 +694,81 @@ function invalidateGroundPolylinePrimitiveGeometry(groundPolylinePrimitive) {
   groundPolylinePrimitive._spMorph = undefined;
 }
 
+/**
+ * Compares the evaluated ground polyline geometry attributes with the ones the
+ * current primitive was built from and refreshes the stored signature.
+ * Returns true when the primitive has to be rebuilt.
+ *
+ * Entity polylines driven by a dynamic property (e.g. a CallbackProperty used
+ * by the editors) are evaluated every frame. Editors usually return the same
+ * positions frame after frame - the camera moves, not the line - so rebuilding
+ * the ground polyline primitive unconditionally would destroy its vertex
+ * arrays and shader programs on every rendered frame, which is very expensive
+ * and makes the line flicker while the view changes.
+ *
+ * @private
+ */
+function updateGroundPolylineSignature(
+  dynamicUpdater,
+  positions,
+  width,
+  arcType,
+  granularity,
+  color,
+) {
+  const length = positions.length;
+  const previous = dynamicUpdater._groundGeometrySignature;
+  const sameLength = defined(previous) && previous.xyz.length === length * 3;
+  const xyz = sameLength ? previous.xyz : new Float64Array(length * 3);
+  const colorChanged =
+    !sameLength ||
+    !defined(previous.color) !== !defined(color) ||
+    (defined(color) &&
+      (previous.color.red !== color.red ||
+        previous.color.green !== color.green ||
+        previous.color.blue !== color.blue ||
+        previous.color.alpha !== color.alpha));
+  let changed =
+    !sameLength ||
+    colorChanged ||
+    previous.width !== width ||
+    previous.arcType !== arcType ||
+    previous.granularity !== granularity;
+
+  // Compare the positions by value: the editors move the nodes of the line
+  // while the property keeps returning an array of the same length, so only
+  // the coordinates tell an edit from a plain re-evaluation.
+  for (let i = 0, j = 0; i < length; ++i) {
+    const position = positions[i];
+    const x = position.x;
+    const y = position.y;
+    const z = position.z;
+    if (!sameLength || xyz[j] !== x || xyz[j + 1] !== y || xyz[j + 2] !== z) {
+      changed = true;
+    }
+    xyz[j++] = x;
+    xyz[j++] = y;
+    xyz[j++] = z;
+  }
+
+  dynamicUpdater._groundGeometrySignature = {
+    xyz,
+    width,
+    arcType,
+    granularity,
+    // Copy the components: colors are evaluated into shared scratch objects.
+    color: defined(color)
+      ? {
+          red: color.red,
+          green: color.green,
+          blue: color.blue,
+          alpha: color.alpha,
+        }
+      : undefined,
+  };
+  return changed;
+}
+
 DynamicGeometryUpdater.prototype.update = function (time) {
   const geometryUpdater = this._geometryUpdater;
   const entity = geometryUpdater._entity;
@@ -754,9 +831,45 @@ DynamicGeometryUpdater.prototype.update = function (time) {
     }
 
     const fillMaterialProperty = geometryUpdater.fillMaterialProperty;
+    const isColorMaterial =
+      fillMaterialProperty instanceof ColorMaterialProperty;
+
+    // Per-instance attributes (show, distance display condition and the
+    // material color) are baked into the geometry instance, so any animated
+    // one of them requires a rebuild every frame.
+    const attributesAnimated =
+      !Property.isConstant(polyline._show) ||
+      !Property.isConstant(geometryUpdater._distanceDisplayConditionProperty) ||
+      (isColorMaterial &&
+        defined(fillMaterialProperty.color) &&
+        !Property.isConstant(fillMaterialProperty.color));
+
+    // The per-instance color is part of the geometry instance as well.
+    const colorAttribute =
+      isColorMaterial && defined(fillMaterialProperty.color)
+        ? fillMaterialProperty.color.getValue(time, scratchColor)
+        : undefined;
+
+    // Only rebuild the ground polyline primitive when the evaluated geometry
+    // actually changed. See updateGroundPolylineSignature.
+    const geometryChanged =
+      attributesAnimated ||
+      updateGroundPolylineSignature(
+        this,
+        positions,
+        geometryUpdater._groundGeometryOptions.width,
+        geometryUpdater._groundGeometryOptions.arcType,
+        geometryUpdater._groundGeometryOptions.granularity,
+        colorAttribute,
+      );
+
     let appearance;
-    if (fillMaterialProperty instanceof ColorMaterialProperty) {
-      appearance = new PolylineColorAppearance();
+    if (isColorMaterial) {
+      // Reuse one appearance instance: assigning a new appearance makes the
+      // primitive rebuild its render states and shader programs.
+      appearance =
+        this._colorAppearance ??
+        (this._colorAppearance = new PolylineColorAppearance());
     } else {
       const material = MaterialProperty.getValue(
         time,
@@ -770,7 +883,6 @@ DynamicGeometryUpdater.prototype.update = function (time) {
       this._material = material;
     }
 
-    const geometryInstance = geometryUpdater.createFillGeometryInstance(time);
     const classificationType =
       geometryUpdater.classificationTypeProperty.getValue(time);
     const zIndex = Property.getValueOrUndefined(geometryUpdater.zIndex, time);
@@ -779,7 +891,7 @@ DynamicGeometryUpdater.prototype.update = function (time) {
     if (!defined(this._groundPolylinePrimitive)) {
       this._groundPolylinePrimitive = groundPrimitives.add(
         new GroundPolylinePrimitive({
-          geometryInstances: geometryInstance,
+          geometryInstances: geometryUpdater.createFillGeometryInstance(time),
           appearance: appearance,
           classificationType: classificationType,
           asynchronous: false,
@@ -791,9 +903,15 @@ DynamicGeometryUpdater.prototype.update = function (time) {
       if (groundPolylinePrimitive._zIndex !== zIndexKey) {
         groundPrimitives.set(groundPolylinePrimitive, zIndexKey);
       }
-      groundPolylinePrimitive.geometryInstances = geometryInstance;
-      invalidateGroundPolylinePrimitiveGeometry(groundPolylinePrimitive);
-      groundPolylinePrimitive.appearance = appearance;
+      if (geometryChanged) {
+        groundPolylinePrimitive.geometryInstances =
+          geometryUpdater.createFillGeometryInstance(time);
+        invalidateGroundPolylinePrimitiveGeometry(groundPolylinePrimitive);
+      }
+      // Animated materials still need their uniforms refreshed per frame.
+      if (geometryChanged || !isColorMaterial) {
+        groundPolylinePrimitive.appearance = appearance;
+      }
       groundPolylinePrimitive.classificationType = classificationType;
     }
 

package/Source/Scene/Camera.js

@@ -26,6 +26,7 @@ import Ray from "../Core/Ray.js";
 import Rectangle from "../Core/Rectangle.js";
 import Transforms from "../Core/Transforms.js";
 import CameraFlightPath from "./CameraFlightPath.js";
+import ColumbusWorlds from "./ColumbusWorlds.js";
 import MapMode2D from "./MapMode2D.js";
 import SceneMode from "./SceneMode.js";
 
@@ -537,6 +538,18 @@ function convertTransformForColumbusView(camera) {
     camera._transform,
     camera._actualTransform,
   );
+
+  if (camera._scene.columbusRepeatWorlds === true) {
+    // Columbus repeat worlds: anchor the converted reference frame on the
+    // world copy nearest the camera (element [13] is the translation's
+    // map-u component in the column-major matrix) so the frame, and offsets
+    // within it, stay continuous with the camera's current copy.
+    camera._actualTransform[13] = ColumbusWorlds.nearestWorldU(
+      camera._positionWC.y,
+      camera._actualTransform[13],
+      camera._projection,
+    );
+  }
 }
 
 const scratchCartographic = new Cartographic();
@@ -752,6 +765,18 @@ function updateMembers(camera) {
       }
 
       camera._projection.unproject(positionENU, camera._positionCartographic);
+
+      if (
+        mode === SceneMode.COLUMBUS_VIEW &&
+        camera._scene.columbusRepeatWorlds === true
+      ) {
+        // Columbus repeat worlds: the camera may sit on any world copy, which
+        // unprojects to a longitude outside [-180°, 180°]; wrap it so
+        // rectangle containment checks see the equivalent primary point.
+        camera._positionCartographic.longitude = CesiumMath.negativePiToPi(
+          camera._positionCartographic.longitude,
+        );
+      }
     }
   }
 
@@ -1315,6 +1340,15 @@ function setViewCV(camera, position, hpr, convert) {
       );
       position = projection.project(cartographic, scratchSetViewCartesian);
     }
+    if (camera._scene.columbusRepeatWorlds === true) {
+      // Columbus repeat worlds: keep the view continuous with the camera's
+      // current world copy instead of snapping back to the primary world.
+      position.x = ColumbusWorlds.nearestWorldU(
+        camera.positionWC.y,
+        position.x,
+        camera._projection,
+      );
+    }
     Cartesian3.clone(position, camera.position);
   }
   hpr.heading = hpr.heading - CesiumMath.PI_OVER_TWO;
@@ -2874,13 +2908,19 @@ function pickMapColumbusView(camera, windowPosition, projection, result) {
 
   if (
     cart.latitude < -CesiumMath.PI_OVER_TWO ||
-    cart.latitude > CesiumMath.PI_OVER_TWO ||
-    cart.longitude < -Math.PI ||
-    cart.longitude > Math.PI
+    cart.latitude > CesiumMath.PI_OVER_TWO
   ) {
     return undefined;
   }
 
+  // The longitude may fall outside [-PI, PI] when Columbus repeat worlds are
+  // enabled and the picked point is on a translated world copy. Accept it:
+  // the returned ECEF position is the equivalent primary-world point, so
+  // picks on world copies succeed instead of returning undefined. Callers
+  // that need to know which copy was picked should use
+  // Globe.pickWorldCoordinates or Scene.pickPosition, which operate in scene
+  // (map-plane) world coordinates.
+
   return projection.ellipsoid.cartographicToCartesian(cart, result);
 }
 
@@ -3190,6 +3230,19 @@ function createAnimationCV(camera, duration) {
 
   position = camera.cameraToWorldCoordinatesPoint(camera.position, posScratch);
 
+  if (camera._scene.columbusRepeatWorlds === true) {
+    // Columbus repeat worlds: the camera may sit on any world copy; wrapping
+    // its map-u coordinate into the primary world is visually identical (the
+    // map repeats) and keeps the bounds checks below meaningful.
+    const worldWidth = ColumbusWorlds.getWorldWidth(camera._projection);
+    position.y =
+      CesiumMath.mod(position.y + worldWidth * 0.5, worldWidth) -
+      worldWidth * 0.5;
+    center.y =
+      CesiumMath.mod(center.y + worldWidth * 0.5, worldWidth) -
+      worldWidth * 0.5;
+  }
+
   const tanPhi = Math.tan(camera.frustum.fovy * 0.5);
   const tanTheta = camera.frustum.aspectRatio * tanPhi;
   const distToC = Cartesian3.magnitude(

package/Source/Scene/CameraFlightPath.js

@@ -8,6 +8,7 @@ import EasingFunction from "../Core/EasingFunction.js";
 import CesiumMath from "../Core/Math.js";
 import PerspectiveFrustum from "../Core/PerspectiveFrustum.js";
 import PerspectiveOffCenterFrustum from "../Core/PerspectiveOffCenterFrustum.js";
+import ColumbusWorlds from "./ColumbusWorlds.js";
 import SceneMode from "./SceneMode.js";
 
 /**
@@ -436,6 +437,19 @@ CameraFlightPath.createTween = function (scene, options) {
   }
 
   const camera = scene.camera;
+
+  if (mode === SceneMode.COLUMBUS_VIEW && scene.columbusRepeatWorlds === true) {
+    // Columbus repeat worlds: fly to the copy of the destination nearest the
+    // camera's current copy so the flight pans locally instead of crossing a
+    // full world. In local (u, v, h) coordinates, u is the x component.
+    scratchDestination.x = ColumbusWorlds.nearestWorldU(
+      camera.position.x,
+      destination.x,
+      projection,
+    );
+    destination = scratchDestination;
+  }
+
   const transform = options.endTransform;
   if (defined(transform)) {
     camera._setTransform(transform);

package/Source/Scene/ClassificationPrimitive.js

@@ -12,6 +12,8 @@ import ShaderProgram from "../Renderer/ShaderProgram.js";
 import ShaderSource from "../Renderer/ShaderSource.js";
 import ShadowVolumeAppearanceVS from "../Shaders/ShadowVolumeAppearanceVS.js";
 import ShadowVolumeFS from "../Shaders/ShadowVolumeFS.js";
+import BlendEquation from "./BlendEquation.js";
+import BlendFunction from "./BlendFunction.js";
 import BlendingState from "./BlendingState.js";
 import ClassificationType from "./ClassificationType.js";
 import DepthFunction from "./DepthFunction.js";
@@ -366,7 +368,61 @@ function getStencilDepthRenderState(enableStencil, mask3DTiles) {
   };
 }
 
-function getColorRenderState(enableStencil) {
+/**
+ * HZ patch: per-material blend modes for ground classification.
+ * The app encodes the mode as a suffix on the composed material type
+ * (e.g. ComposedPolygon_..._blendScreen). Source fragments are
+ * premultiplied (ShadowVolumeAppearanceFS: rgb *= alpha), so:
+ *   screen   = src + dst * (1 - src)                  -> (ONE, ONE_MINUS_SRC_COLOR)
+ *   multiply = dst * mix(1, c, a)  (alpha-gated)      -> (DST_COLOR, ONE_MINUS_SRC_ALPHA)
+ *   additive = src + dst                             -> (ONE, ONE)
+ * Alpha keeps standard premultiplied over except additive.
+ */
+const classificationBlendOverrides = {
+  _blendScreen: {
+    enabled: true,
+    equationRgb: BlendEquation.ADD,
+    equationAlpha: BlendEquation.ADD,
+    functionSourceRgb: BlendFunction.ONE,
+    functionSourceAlpha: BlendFunction.ONE,
+    functionDestinationRgb: BlendFunction.ONE_MINUS_SOURCE_COLOR,
+    functionDestinationAlpha: BlendFunction.ONE_MINUS_SOURCE_ALPHA,
+  },
+  _blendMultiply: {
+    enabled: true,
+    equationRgb: BlendEquation.ADD,
+    equationAlpha: BlendEquation.ADD,
+    functionSourceRgb: BlendFunction.DESTINATION_COLOR,
+    functionSourceAlpha: BlendFunction.ONE,
+    functionDestinationRgb: BlendFunction.ONE_MINUS_SOURCE_ALPHA,
+    functionDestinationAlpha: BlendFunction.ONE_MINUS_SOURCE_ALPHA,
+  },
+  _blendAdditive: {
+    enabled: true,
+    equationRgb: BlendEquation.ADD,
+    equationAlpha: BlendEquation.ADD,
+    functionSourceRgb: BlendFunction.ONE,
+    functionSourceAlpha: BlendFunction.ONE,
+    functionDestinationRgb: BlendFunction.ONE,
+    functionDestinationAlpha: BlendFunction.ONE,
+  },
+};
+
+/** HZ patch: material type suffix -> blending override (undefined = stock) */
+function getClassificationBlendOverride(classificationPrimitive) {
+  const type = classificationPrimitive.appearance?.material?.type;
+  if (typeof type !== "string") {
+    return undefined;
+  }
+  for (const suffix of Object.keys(classificationBlendOverrides)) {
+    if (type.endsWith(suffix)) {
+      return classificationBlendOverrides[suffix];
+    }
+  }
+  return undefined;
+}
+
+function getColorRenderState(enableStencil, blending) {
   return {
     stencilTest: {
       enabled: enableStencil,
@@ -390,7 +446,7 @@ function getColorRenderState(enableStencil) {
       enabled: false,
     },
     depthMask: false,
-    blending: BlendingState.PRE_MULTIPLIED_ALPHA_BLEND,
+    blending: blending ?? BlendingState.PRE_MULTIPLIED_ALPHA_BLEND,
   };
 }
 
@@ -436,8 +492,12 @@ function createRenderStates(
   classificationPrimitive._rsStencilDepthPass3DTiles = RenderState.fromCache(
     getStencilDepthRenderState(stencilEnabled, true),
   );
+  // HZ patch: honor per-material blend mode encoded in the material type
   classificationPrimitive._rsColorPass = RenderState.fromCache(
-    getColorRenderState(stencilEnabled, false),
+    getColorRenderState(
+      stencilEnabled,
+      getClassificationBlendOverride(classificationPrimitive),
+    ),
   );
   classificationPrimitive._rsPickPass = RenderState.fromCache(pickRenderState);
 }

package/Source/Scene/ColumbusWorlds.js

@@ -0,0 +1,190 @@
+import BoundingSphere from "../Core/BoundingSphere.js";
+import Cartesian3 from "../Core/Cartesian3.js";
+import Cartesian4 from "../Core/Cartesian4.js";
+import Cartographic from "../Core/Cartographic.js";
+import defined from "../Core/defined.js";
+import IntersectionTests from "../Core/IntersectionTests.js";
+import Matrix4 from "../Core/Matrix4.js";
+import Rectangle from "../Core/Rectangle.js";
+
+/**
+ * Shared helpers for Columbus View repeat worlds: when
+ * {@link Scene#columbusRepeatWorlds} is enabled, the map surface repeats
+ * horizontally in whole-world copies (each 360° of longitude wide), so
+ * positions and camera destinations must be placed on the copy nearest the
+ * camera instead of the primary [-180°, 180°] world.
+ *
+ * @namespace ColumbusWorlds
+ */
+
+const ColumbusWorlds = {};
+
+const worldWidthCartographic = new Cartographic();
+const worldWidthCartesian = new Cartesian3();
+const worldWidthCache = {
+  projection: undefined,
+  width: 0.0,
+};
+
+/**
+ * The projected width of one full world (360° of longitude) for the given
+ * map projection. Cached per projection instance.
+ *
+ * @param {object} projection The map projection.
+ * @returns {number} The world width in projected units (meters).
+ *
+ * @private
+ */
+ColumbusWorlds.getWorldWidth = function (projection) {
+  if (worldWidthCache.projection !== projection) {
+    const northeast = projection.project(
+      Rectangle.northeast(Rectangle.MAX_VALUE, worldWidthCartographic),
+      worldWidthCartesian,
+    );
+    worldWidthCache.projection = projection;
+    worldWidthCache.width = Math.abs(northeast.x) * 2.0;
+  }
+  return worldWidthCache.width;
+};
+
+/**
+ * Places a projected map-u coordinate on the world copy nearest the camera.
+ * ECEF positions normalize longitude to the primary world, so a position
+ * intended for a translated copy (e.g. edited at 185° while its ECEF form
+ * reads as -175°) would otherwise land a full world away from the camera
+ * with no way to tell which copy was meant. The nearest-copy rule resolves
+ * that ambiguity; positions hop worlds only when the camera moves more than
+ * half a world away, at which point they are far off screen.
+ *
+ * @param {number} cameraU The camera's projected map-u coordinate.
+ * @param {number} u The projected map-u coordinate to place.
+ * @param {object} projection The map projection.
+ * @returns {number} The map-u coordinate shifted to the nearest world copy.
+ *
+ * @private
+ */
+ColumbusWorlds.nearestWorldU = function (cameraU, u, projection) {
+  const worldWidth = ColumbusWorlds.getWorldWidth(projection);
+  return u + Math.round((cameraU - u) / worldWidth) * worldWidth;
+};
+
+const cameraOffsetDelta = new Cartesian3();
+const cameraOffsetTranslation = new Matrix4();
+
+/**
+ * Shifts a camera so the scene draws world copy `worldOffset` instead of the
+ * primary world, without duplicating any geometry. Rendering copy k at
+ * `p + worldOffset` is equivalent to viewing the unshifted scene from a camera
+ * moved by `-worldOffset`: `view' = view * translate(worldOffset)` and
+ * `eye' = eye - worldOffset` (map-u is the y axis of Columbus view world
+ * coordinates). The camera's direction, up and right are unchanged, so
+ * screen-space sizes and depth ordering are preserved.
+ *
+ * The camera's derived members are mutated directly (not `_position`) so
+ * `updateMembers` does not recompute them from the primary camera frame; the
+ * caller is responsible for restoring them when done.
+ *
+ * @param {Camera} camera The camera to offset.
+ * @param {number} worldOffset The world copy offset along map-u, in meters.
+ *
+ * @private
+ */
+ColumbusWorlds.applyCameraWorldOffset = function (camera, worldOffset) {
+  Cartesian3.fromElements(0.0, worldOffset, 0.0, cameraOffsetDelta);
+  Matrix4.fromTranslation(cameraOffsetDelta, cameraOffsetTranslation);
+  Matrix4.multiply(
+    camera._viewMatrix,
+    cameraOffsetTranslation,
+    camera._viewMatrix,
+  );
+  Matrix4.inverseTransformation(camera._viewMatrix, camera._invViewMatrix);
+  camera._positionWC.y -= worldOffset;
+};
+
+/**
+ * Returns a culling volume translated the same way as the camera by
+ * {@link ColumbusWorlds.applyCameraWorldOffset}: the supplied volume is the
+ * primary-world frustum, the result is the frustum of the shifted camera.
+ * Planes are `n · p + w = 0`; translating a volume by `t` yields
+ * `w' = w - n · t`, and the camera offset is `t = (0, -worldOffset, 0)`.
+ *
+ * @param {CullingVolume} cullingVolume The primary-world culling volume.
+ * @param {number} worldOffset The world copy offset along map-u, in meters.
+ * @param {CullingVolume} result The culling volume to write into.
+ * @returns {CullingVolume} The modified result parameter.
+ *
+ * @private
+ */
+ColumbusWorlds.translateCullingVolume = function (
+  cullingVolume,
+  worldOffset,
+  result,
+) {
+  const planes = cullingVolume.planes;
+  const resultPlanes = result.planes;
+  for (let i = 0; i < planes.length; ++i) {
+    const plane = planes[i];
+    let resultPlane = resultPlanes[i];
+    if (!defined(resultPlane)) {
+      resultPlane = resultPlanes[i] = new Cartesian4();
+    }
+    resultPlane.x = plane.x;
+    resultPlane.y = plane.y;
+    resultPlane.z = plane.z;
+    resultPlane.w = plane.w + plane.y * worldOffset;
+  }
+  return result;
+};
+
+const worldStripSphere = new BoundingSphere();
+
+/**
+ * Collects the non-primary world copy indices worth rendering for the given
+ * camera. The globe surface provider uses the same camera-centered window, so
+ * both the basemap and the data copies cover the same worlds. A conservative
+ * strip sphere keeps copies that are entirely off screen (for instance when
+ * zoomed far in) from costing an extra visible-set build and pass.
+ *
+ * @param {number} cameraU The camera's projected map-u coordinate.
+ * @param {number} worldWidth The projected world width, in meters.
+ * @param {CullingVolume} cullingVolume The primary-world culling volume.
+ * @param {number} maxExtraWorlds The number of copies to try on each side.
+ * @param {number[]} result The array to write the world indices into.
+ * @returns {number[]} The modified result parameter.
+ *
+ * @private
+ */
+ColumbusWorlds.getVisibleWorldIndices = function (
+  cameraU,
+  worldWidth,
+  cullingVolume,
+  maxExtraWorlds,
+  result,
+) {
+  result.length = 0;
+  if (!(worldWidth > 0.0) || !Number.isFinite(cameraU)) {
+    return result;
+  }
+
+  const sphere = worldStripSphere;
+  sphere.center.x = 0.0;
+  sphere.center.z = 0.0;
+  sphere.radius = worldWidth * 0.75;
+
+  const centerWorld = Math.round(cameraU / worldWidth);
+  for (let i = -maxExtraWorlds; i <= maxExtraWorlds; ++i) {
+    const worldIndex = centerWorld + i;
+    if (worldIndex === 0) {
+      // The primary world is rendered by the regular passes.
+      continue;
+    }
+    sphere.center.y = worldIndex * worldWidth;
+    if (cullingVolume.computeVisibility(sphere) === IntersectionTests.OUTSIDE) {
+      continue;
+    }
+    result.push(worldIndex);
+  }
+  return result;
+};
+
+export default ColumbusWorlds;

package/Source/Scene/FrameState.js

@@ -126,6 +126,16 @@ function FrameState(context, creditDisplay, jobScheduler) {
    */
   this.mapProjection = undefined;
 
+  /**
+   * Whether the map repeats horizontally in Columbus View, rendering
+   * translated copies of the globe surface tiles so the surface continues
+   * seamlessly beyond the ±180° meridian.
+   *
+   * @type {boolean}
+   * @default false
+   */
+  this.columbusRepeatWorlds = false;
+
   /**
    * The current camera.
    *