@cesium/engine 22.0.0 → 22.1.0

package/Build/Workers/{chunk-7XEJGXX2.js → chunk-WB4TSSBQ.js}

@@ -1,7 +1,7 @@
 /**
  * @license
  * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.135.0
+ * Version 1.136.0
  *
  * Copyright 2011-2022 Cesium Contributors
  *
@@ -25,49 +25,73 @@
 
 import {
   TerrainProvider_default
-} from "./chunk-34YXP222.js";
+} from "./chunk-HXKUEOOD.js";
 import {
   EllipsoidalOccluder_default,
-  TerrainEncoding_default
-} from "./chunk-P2H75UV5.js";
+  TerrainEncoding_default,
+  VerticalExaggeration_default
+} from "./chunk-MKMZHRB3.js";
 import {
   WebMercatorProjection_default
-} from "./chunk-LWJXCI3F.js";
+} from "./chunk-H6Q7E4BQ.js";
 import {
   OrientedBoundingBox_default
-} from "./chunk-KGLDJRSO.js";
+} from "./chunk-YF2NVO5B.js";
 import {
   AttributeCompression_default
-} from "./chunk-6HBKE43B.js";
+} from "./chunk-RXZDTDIY.js";
 import {
   AxisAlignedBoundingBox_default
-} from "./chunk-NGKF5NTR.js";
+} from "./chunk-OXFU5HNU.js";
 import {
-  BoundingSphere_default
-} from "./chunk-MXHRZHDF.js";
+  IntersectionTests_default,
+  Ray_default
+} from "./chunk-DMEFNTUV.js";
 import {
-  Matrix4_default,
+  BoundingSphere_default,
+  Interval_default
+} from "./chunk-GDU4RZSZ.js";
+import {
+  Event_default,
   Rectangle_default,
+  Resource_default,
   Transforms_default,
-  binarySearch_default
-} from "./chunk-3GL53OCU.js";
+  binarySearch_default,
+  buildModuleUrl_default,
+  isCrossOriginUrl_default,
+  require_URI
+} from "./chunk-AOIO5VUS.js";
+import {
+  Matrix4_default
+} from "./chunk-W4XUEDU5.js";
 import {
   ComponentDatatype_default
-} from "./chunk-EZ7NJXQN.js";
+} from "./chunk-I4REFVXB.js";
+import {
+  RuntimeError_default
+} from "./chunk-5JKH4AMT.js";
 import {
   Cartesian2_default,
-  Cartesian3_default,
   Cartographic_default,
   Ellipsoid_default,
+  FeatureDetection_default
+} from "./chunk-TDSVSW5A.js";
+import {
+  Cartesian3_default,
   Frozen_default,
   Matrix3_default
-} from "./chunk-RQRODXVN.js";
+} from "./chunk-3YTMGEXW.js";
 import {
   Math_default
-} from "./chunk-OE22564R.js";
+} from "./chunk-IL5F6WEE.js";
+import {
+  Check_default,
+  DeveloperError_default
+} from "./chunk-QEANVUGT.js";
 import {
-  Check_default
-} from "./chunk-W4PIP5PG.js";
+  __toESM,
+  defined_default
+} from "./chunk-2RCIRXNI.js";
 
 // node_modules/meshoptimizer/meshopt_encoder.module.js
 var MeshoptEncoder = (function() {
@@ -490,7 +514,7 @@ var MeshoptDecoder = (function() {
   };
   var workers = [];
   var requestId = 0;
-  function createWorker(url) {
+  function createWorker2(url) {
     var worker = {
       object: new Worker(url),
       pending: 0,
@@ -509,7 +533,7 @@ var MeshoptDecoder = (function() {
     var blob = new Blob([source], { type: "text/javascript" });
     var url = URL.createObjectURL(blob);
     for (var i = workers.length; i < count; ++i) {
-      workers[i] = createWorker(url);
+      workers[i] = createWorker2(url);
     }
     for (var i = count; i < workers.length; ++i) {
       workers[i].object.postMessage({});
@@ -1451,8 +1475,627 @@ Axis.fromName = function(name) {
 };
 var Axis_default = Object.freeze(Axis);
 
+// packages/engine/Source/Scene/SceneMode.js
+var SceneMode = {
+  /**
+   * Morphing between mode, e.g., 3D to 2D.
+   *
+   * @type {number}
+   * @constant
+   */
+  MORPHING: 0,
+  /**
+   * Columbus View mode.  A 2.5D perspective view where the map is laid out
+   * flat and objects with non-zero height are drawn above it.
+   *
+   * @type {number}
+   * @constant
+   */
+  COLUMBUS_VIEW: 1,
+  /**
+   * 2D mode.  The map is viewed top-down with an orthographic projection.
+   *
+   * @type {number}
+   * @constant
+   */
+  SCENE2D: 2,
+  /**
+   * 3D mode.  A traditional 3D perspective view of the globe.
+   *
+   * @type {number}
+   * @constant
+   */
+  SCENE3D: 3
+};
+SceneMode.getMorphTime = function(value) {
+  if (value === SceneMode.SCENE3D) {
+    return 1;
+  } else if (value === SceneMode.MORPHING) {
+    return void 0;
+  }
+  return 0;
+};
+var SceneMode_default = Object.freeze(SceneMode);
+
+// packages/engine/Source/Core/TaskProcessor.js
+var import_urijs = __toESM(require_URI(), 1);
+
+// packages/engine/Source/Core/destroyObject.js
+function returnTrue() {
+  return true;
+}
+function destroyObject(object, message) {
+  message = message ?? "This object was destroyed, i.e., destroy() was called.";
+  function throwOnDestroyed() {
+    throw new DeveloperError_default(message);
+  }
+  for (const key in object) {
+    if (typeof object[key] === "function") {
+      object[key] = throwOnDestroyed;
+    }
+  }
+  object.isDestroyed = returnTrue;
+  return void 0;
+}
+var destroyObject_default = destroyObject;
+
+// packages/engine/Source/Core/TaskProcessor.js
+function canTransferArrayBuffer() {
+  if (!defined_default(TaskProcessor._canTransferArrayBuffer)) {
+    const worker = createWorker("transferTypedArrayTest");
+    worker.postMessage = worker.webkitPostMessage ?? worker.postMessage;
+    const value = 99;
+    const array = new Int8Array([value]);
+    try {
+      worker.postMessage(
+        {
+          array
+        },
+        [array.buffer]
+      );
+    } catch (e) {
+      TaskProcessor._canTransferArrayBuffer = false;
+      return TaskProcessor._canTransferArrayBuffer;
+    }
+    TaskProcessor._canTransferArrayBuffer = new Promise((resolve) => {
+      worker.onmessage = function(event) {
+        const array2 = event.data.array;
+        const result = defined_default(array2) && array2[0] === value;
+        resolve(result);
+        worker.terminate();
+        TaskProcessor._canTransferArrayBuffer = result;
+      };
+    });
+  }
+  return TaskProcessor._canTransferArrayBuffer;
+}
+var taskCompletedEvent = new Event_default();
+function urlFromScript(script) {
+  let blob;
+  try {
+    blob = new Blob([script], {
+      type: "application/javascript"
+    });
+  } catch (e) {
+    const BlobBuilder = window.BlobBuilder || window.WebKitBlobBuilder || window.MozBlobBuilder || window.MSBlobBuilder;
+    const blobBuilder = new BlobBuilder();
+    blobBuilder.append(script);
+    blob = blobBuilder.getBlob("application/javascript");
+  }
+  const URL2 = window.URL || window.webkitURL;
+  return URL2.createObjectURL(blob);
+}
+function createWorker(url) {
+  const uri = new import_urijs.default(url);
+  const isUri = uri.scheme().length !== 0 && uri.fragment().length === 0;
+  const moduleID = url.replace(/\.js$/, "");
+  const options = {};
+  let workerPath;
+  let crossOriginUrl;
+  if (isCrossOriginUrl_default(url)) {
+    crossOriginUrl = url;
+  } else if (!isUri) {
+    const moduleAbsoluteUrl = buildModuleUrl_default(
+      `${TaskProcessor._workerModulePrefix}/${moduleID}.js`
+    );
+    if (isCrossOriginUrl_default(moduleAbsoluteUrl)) {
+      crossOriginUrl = moduleAbsoluteUrl;
+    }
+  }
+  if (crossOriginUrl) {
+    const script = `import "${crossOriginUrl}";`;
+    workerPath = urlFromScript(script);
+    options.type = "module";
+    return new Worker(workerPath, options);
+  }
+  if (!isUri && typeof CESIUM_WORKERS !== "undefined") {
+    const script = `
+      importScripts("${urlFromScript(CESIUM_WORKERS)}");
+      CesiumWorkers["${moduleID}"]();
+    `;
+    workerPath = urlFromScript(script);
+    return new Worker(workerPath, options);
+  }
+  workerPath = url;
+  if (!isUri) {
+    workerPath = buildModuleUrl_default(
+      `${TaskProcessor._workerModulePrefix + moduleID}.js`
+    );
+  }
+  if (!FeatureDetection_default.supportsEsmWebWorkers()) {
+    throw new RuntimeError_default(
+      "This browser is not supported. Please update your browser to continue."
+    );
+  }
+  options.type = "module";
+  return new Worker(workerPath, options);
+}
+async function getWebAssemblyLoaderConfig(processor, wasmOptions) {
+  const config = {
+    modulePath: void 0,
+    wasmBinaryFile: void 0,
+    wasmBinary: void 0
+  };
+  if (!FeatureDetection_default.supportsWebAssembly()) {
+    if (!defined_default(wasmOptions.fallbackModulePath)) {
+      throw new RuntimeError_default(
+        `This browser does not support Web Assembly, and no backup module was provided for ${processor._workerPath}`
+      );
+    }
+    config.modulePath = buildModuleUrl_default(wasmOptions.fallbackModulePath);
+    return config;
+  }
+  config.wasmBinaryFile = buildModuleUrl_default(wasmOptions.wasmBinaryFile);
+  const arrayBuffer = await Resource_default.fetchArrayBuffer({
+    url: config.wasmBinaryFile
+  });
+  config.wasmBinary = arrayBuffer;
+  return config;
+}
+function TaskProcessor(workerPath, maximumActiveTasks) {
+  this._workerPath = workerPath;
+  this._maximumActiveTasks = maximumActiveTasks ?? Number.POSITIVE_INFINITY;
+  this._activeTasks = 0;
+  this._nextID = 0;
+  this._webAssemblyPromise = void 0;
+}
+var createOnmessageHandler = (worker, id, resolve, reject) => {
+  const listener = ({ data }) => {
+    if (data.id !== id) {
+      return;
+    }
+    if (defined_default(data.error)) {
+      let error = data.error;
+      if (error.name === "RuntimeError") {
+        error = new RuntimeError_default(data.error.message);
+        error.stack = data.error.stack;
+      } else if (error.name === "DeveloperError") {
+        error = new DeveloperError_default(data.error.message);
+        error.stack = data.error.stack;
+      } else if (error.name === "Error") {
+        error = new Error(data.error.message);
+        error.stack = data.error.stack;
+      }
+      taskCompletedEvent.raiseEvent(error);
+      reject(error);
+    } else {
+      taskCompletedEvent.raiseEvent();
+      resolve(data.result);
+    }
+    worker.removeEventListener("message", listener);
+  };
+  return listener;
+};
+var emptyTransferableObjectArray = [];
+async function runTask(processor, parameters, transferableObjects) {
+  const canTransfer = await Promise.resolve(canTransferArrayBuffer());
+  if (!defined_default(transferableObjects)) {
+    transferableObjects = emptyTransferableObjectArray;
+  } else if (!canTransfer) {
+    transferableObjects.length = 0;
+  }
+  const id = processor._nextID++;
+  const promise = new Promise((resolve, reject) => {
+    processor._worker.addEventListener(
+      "message",
+      createOnmessageHandler(processor._worker, id, resolve, reject)
+    );
+  });
+  processor._worker.postMessage(
+    {
+      id,
+      baseUrl: buildModuleUrl_default.getCesiumBaseUrl().url,
+      parameters,
+      canTransferArrayBuffer: canTransfer
+    },
+    transferableObjects
+  );
+  return promise;
+}
+async function scheduleTask(processor, parameters, transferableObjects) {
+  ++processor._activeTasks;
+  try {
+    const result = await runTask(processor, parameters, transferableObjects);
+    --processor._activeTasks;
+    return result;
+  } catch (error) {
+    --processor._activeTasks;
+    throw error;
+  }
+}
+TaskProcessor.prototype.scheduleTask = function(parameters, transferableObjects) {
+  if (!defined_default(this._worker)) {
+    this._worker = createWorker(this._workerPath);
+  }
+  if (this._activeTasks >= this._maximumActiveTasks) {
+    return void 0;
+  }
+  return scheduleTask(this, parameters, transferableObjects);
+};
+TaskProcessor.prototype.initWebAssemblyModule = async function(webAssemblyOptions) {
+  if (defined_default(this._webAssemblyPromise)) {
+    return this._webAssemblyPromise;
+  }
+  const init = async () => {
+    const worker = this._worker = createWorker(this._workerPath);
+    const wasmConfig = await getWebAssemblyLoaderConfig(
+      this,
+      webAssemblyOptions
+    );
+    const canTransfer = await Promise.resolve(canTransferArrayBuffer());
+    let transferableObjects;
+    const binary = wasmConfig.wasmBinary;
+    if (defined_default(binary) && canTransfer) {
+      transferableObjects = [binary];
+    }
+    const promise = new Promise((resolve, reject) => {
+      worker.onmessage = function({ data }) {
+        if (defined_default(data)) {
+          resolve(data.result);
+        } else {
+          reject(new RuntimeError_default("Could not configure wasm module"));
+        }
+      };
+    });
+    worker.postMessage(
+      {
+        canTransferArrayBuffer: canTransfer,
+        parameters: { webAssemblyConfig: wasmConfig }
+      },
+      transferableObjects
+    );
+    return promise;
+  };
+  this._webAssemblyPromise = init();
+  return this._webAssemblyPromise;
+};
+TaskProcessor.prototype.isDestroyed = function() {
+  return false;
+};
+TaskProcessor.prototype.destroy = function() {
+  if (defined_default(this._worker)) {
+    this._worker.terminate();
+  }
+  return destroyObject_default(this);
+};
+TaskProcessor.taskCompletedEvent = taskCompletedEvent;
+TaskProcessor._defaultWorkerModulePrefix = "Workers/";
+TaskProcessor._workerModulePrefix = TaskProcessor._defaultWorkerModulePrefix;
+TaskProcessor._canTransferArrayBuffer = void 0;
+var TaskProcessor_default = TaskProcessor;
+
+// packages/engine/Source/Core/TerrainPicker.js
+var MAXIMUM_TERRAIN_PICKER_LEVEL = 3;
+function TerrainPicker(vertices, indices, encoding) {
+  Check_default.defined("vertices", vertices);
+  Check_default.defined("indices", indices);
+  Check_default.defined("encoding", encoding);
+  this._vertices = vertices;
+  this._indices = indices;
+  this._encoding = encoding;
+  this._inverseTransform = new Matrix4_default();
+  this._needsRebuild = true;
+  this._rootNode = new TerrainPickerNode();
+}
+var incrementallyBuildTerrainPickerTaskProcessor = new TaskProcessor_default(
+  "incrementallyBuildTerrainPicker"
+);
+Object.defineProperties(TerrainPicker.prototype, {
+  /**
+   * Indicates whether the terrain picker needs to be rebuilt due to changes in the underlying terrain mesh's vertices or indices.
+   * @type {boolean}
+   */
+  needsRebuild: {
+    get: function() {
+      return this._needsRebuild;
+    },
+    set: function(value) {
+      this._needsRebuild = value;
+    }
+  }
+});
+function TerrainPickerNode() {
+  this.x = 0;
+  this.y = 0;
+  this.level = 0;
+  this.aabb = createAABBForNode(this.x, this.y, this.level);
+  this.intersectingTriangles = new Uint32Array(0);
+  this.children = [];
+  this.buildingChildren = false;
+}
+TerrainPickerNode.prototype.addChild = function(childIdx) {
+  if (childIdx < 0 || childIdx > 3) {
+    throw new DeveloperError_default(
+      "TerrainPickerNode child index must be between 0 and 3, inclusive."
+    );
+  }
+  const childNode = new TerrainPickerNode();
+  childNode.x = this.x * 2 + (childIdx & 1);
+  childNode.y = this.y * 2 + (childIdx >> 1 & 1);
+  childNode.level = this.level + 1;
+  childNode.aabb = createAABBForNode(childNode.x, childNode.y, childNode.level);
+  this.children[childIdx] = childNode;
+};
+var scratchTransformedRay = new Ray_default();
+var scratchTrianglePoints = [
+  new Cartesian3_default(),
+  new Cartesian3_default(),
+  new Cartesian3_default()
+];
+TerrainPicker.prototype.rayIntersect = function(ray, tileTransform, cullBackFaces, mode, projection) {
+  if (this._needsRebuild) {
+    reset(this, tileTransform);
+  }
+  const invTransform = this._inverseTransform;
+  const transformedRay = scratchTransformedRay;
+  transformedRay.origin = Matrix4_default.multiplyByPoint(
+    invTransform,
+    ray.origin,
+    transformedRay.origin
+  );
+  transformedRay.direction = Matrix4_default.multiplyByPointAsVector(
+    invTransform,
+    ray.direction,
+    transformedRay.direction
+  );
+  const intersections = [];
+  getNodesIntersectingRay(this._rootNode, transformedRay, intersections);
+  return findClosestPointInClosestNode(
+    this,
+    intersections,
+    ray,
+    cullBackFaces,
+    mode,
+    projection
+  );
+};
+function reset(terrainPicker, tileTransform) {
+  Matrix4_default.inverse(tileTransform, terrainPicker._inverseTransform);
+  terrainPicker._needsRebuild = false;
+  const triangleCount = terrainPicker._indices.length / 3;
+  const intersectingTriangles = new Uint32Array(triangleCount);
+  for (let i = 0; i < triangleCount; ++i) {
+    intersectingTriangles[i] = i;
+  }
+  terrainPicker._rootNode.intersectingTriangles = intersectingTriangles;
+  terrainPicker._rootNode.children.length = 0;
+}
+var scratchAABBMin = new Cartesian3_default();
+var scratchAABBMax = new Cartesian3_default();
+function createAABBForNode(x, y, level) {
+  const sizeAtLevel = 1 / Math.pow(2, level);
+  const aabbMin = Cartesian3_default.fromElements(
+    x * sizeAtLevel - 0.5,
+    y * sizeAtLevel - 0.5,
+    -0.5,
+    scratchAABBMin
+  );
+  const aabbMax = Cartesian3_default.fromElements(
+    (x + 1) * sizeAtLevel - 0.5,
+    (y + 1) * sizeAtLevel - 0.5,
+    0.5,
+    scratchAABBMax
+  );
+  return AxisAlignedBoundingBox_default.fromCorners(aabbMin, aabbMax);
+}
+function packTriangleBuffers(trianglePositionsBuffer, triangleIndicesBuffer, trianglePositions, triangleIndex, bufferIndex) {
+  Cartesian3_default.pack(
+    trianglePositions[0],
+    trianglePositionsBuffer,
+    9 * bufferIndex
+  );
+  Cartesian3_default.pack(
+    trianglePositions[1],
+    trianglePositionsBuffer,
+    9 * bufferIndex + 3
+  );
+  Cartesian3_default.pack(
+    trianglePositions[2],
+    trianglePositionsBuffer,
+    9 * bufferIndex + 6
+  );
+  triangleIndicesBuffer[bufferIndex] = triangleIndex;
+}
+var scratchInterval = new Interval_default();
+function getNodesIntersectingRay(currentNode, ray, intersectingNodes) {
+  const interval = IntersectionTests_default.rayAxisAlignedBoundingBox(
+    ray,
+    currentNode.aabb,
+    scratchInterval
+  );
+  if (!defined_default(interval)) {
+    return;
+  }
+  const isLeaf = !currentNode.children.length || currentNode.buildingChildren;
+  if (isLeaf) {
+    intersectingNodes.push({
+      node: currentNode,
+      interval: new Interval_default(interval.start, interval.stop)
+    });
+    return;
+  }
+  for (let i = 0; i < currentNode.children.length; i++) {
+    getNodesIntersectingRay(currentNode.children[i], ray, intersectingNodes);
+  }
+}
+function findClosestPointInClosestNode(terrainPicker, intersections, ray, cullBackFaces, mode, projection) {
+  const sortedIntersections = intersections.sort(function(a, b) {
+    return a.interval.start - b.interval.start;
+  });
+  let minT = Number.MAX_VALUE;
+  for (let i = 0; i < sortedIntersections.length; i++) {
+    const intersection = sortedIntersections[i];
+    const intersectionResult = getClosestTriangleInNode(
+      terrainPicker,
+      ray,
+      intersection.node,
+      cullBackFaces,
+      mode,
+      projection
+    );
+    minT = Math.min(intersectionResult, minT);
+    if (minT !== Number.MAX_VALUE) {
+      break;
+    }
+  }
+  if (minT !== Number.MAX_VALUE) {
+    return Ray_default.getPoint(ray, minT);
+  }
+  return void 0;
+}
+function getClosestTriangleInNode(terrainPicker, ray, node, cullBackFaces, mode, projection) {
+  let result = Number.MAX_VALUE;
+  const encoding = terrainPicker._encoding;
+  const indices = terrainPicker._indices;
+  const vertices = terrainPicker._vertices;
+  const triangleCount = node.intersectingTriangles.length;
+  const isMaxLevel = node.level >= MAXIMUM_TERRAIN_PICKER_LEVEL;
+  const shouldBuildChildren = !isMaxLevel && !node.buildingChildren;
+  let trianglePositions;
+  let triangleIndices;
+  if (shouldBuildChildren) {
+    trianglePositions = new Float32Array(triangleCount * 9);
+    triangleIndices = new Uint32Array(triangleCount);
+  }
+  for (let i = 0; i < triangleCount; i++) {
+    const triIndex = node.intersectingTriangles[i];
+    const v0 = getVertexPosition(
+      encoding,
+      mode,
+      projection,
+      vertices,
+      indices[3 * triIndex],
+      scratchTrianglePoints[0]
+    );
+    const v1 = getVertexPosition(
+      encoding,
+      mode,
+      projection,
+      vertices,
+      indices[3 * triIndex + 1],
+      scratchTrianglePoints[1]
+    );
+    const v2 = getVertexPosition(
+      encoding,
+      mode,
+      projection,
+      vertices,
+      indices[3 * triIndex + 2],
+      scratchTrianglePoints[2]
+    );
+    const triT = IntersectionTests_default.rayTriangleParametric(
+      ray,
+      v0,
+      v1,
+      v2,
+      cullBackFaces
+    );
+    if (defined_default(triT) && triT < result && triT >= 0) {
+      result = triT;
+    }
+    if (shouldBuildChildren) {
+      packTriangleBuffers(
+        trianglePositions,
+        triangleIndices,
+        scratchTrianglePoints,
+        triIndex,
+        i
+      );
+    }
+  }
+  if (shouldBuildChildren) {
+    for (let childIdx = 0; childIdx < 4; childIdx++) {
+      node.addChild(childIdx);
+    }
+    addTrianglesToChildrenNodes(
+      terrainPicker._inverseTransform,
+      node,
+      triangleIndices,
+      trianglePositions
+    );
+  }
+  return result;
+}
+var scratchCartographic = new Cartographic_default();
+function getVertexPosition(encoding, mode, projection, vertices, index, result) {
+  let position = encoding.getExaggeratedPosition(vertices, index, result);
+  if (mode === SceneMode_default.SCENE3D) {
+    return position;
+  }
+  const ellipsoid = projection.ellipsoid;
+  const positionCartographic = ellipsoid.cartesianToCartographic(
+    position,
+    scratchCartographic
+  );
+  position = projection.project(positionCartographic, result);
+  position = Cartesian3_default.fromElements(
+    position.z,
+    position.x,
+    position.y,
+    result
+  );
+  return position;
+}
+async function addTrianglesToChildrenNodes(inverseTransform, node, triangleIndices, trianglePositions) {
+  node.buildingChildren = true;
+  const inverseTransformPacked = new Float64Array(16);
+  Matrix4_default.pack(inverseTransform, inverseTransformPacked, 0);
+  const aabbArray = new Float64Array(6 * 4);
+  for (let i = 0; i < 4; i++) {
+    Cartesian3_default.pack(node.children[i].aabb.minimum, aabbArray, i * 6);
+    Cartesian3_default.pack(node.children[i].aabb.maximum, aabbArray, i * 6 + 3);
+  }
+  const parameters = {
+    aabbs: aabbArray,
+    inverseTransform: inverseTransformPacked,
+    triangleIndices,
+    trianglePositions
+  };
+  const transferableObjects = [
+    aabbArray.buffer,
+    inverseTransformPacked.buffer,
+    triangleIndices.buffer,
+    trianglePositions.buffer
+  ];
+  const incrementallyBuildTerrainPickerPromise = incrementallyBuildTerrainPickerTaskProcessor.scheduleTask(
+    parameters,
+    transferableObjects
+  );
+  if (!defined_default(incrementallyBuildTerrainPickerPromise)) {
+    node.buildingChildren = false;
+    return;
+  }
+  const result = await incrementallyBuildTerrainPickerPromise;
+  result.intersectingTrianglesArrays.forEach((buffer, index) => {
+    node.children[index].intersectingTriangles = new Uint32Array(buffer);
+  });
+  node.intersectingTriangles = new Uint32Array(0);
+  node.buildingChildren = false;
+}
+var TerrainPicker_default = TerrainPicker;
+
 // packages/engine/Source/Core/TerrainMesh.js
-function TerrainMesh(center, vertices, indices, indexCountWithoutSkirts, vertexCountWithoutSkirts, minimumHeight, maximumHeight, boundingSphere3D, occludeePointInScaledSpace, vertexStride, orientedBoundingBox, encoding, westIndicesSouthToNorth, southIndicesEastToWest, eastIndicesNorthToSouth, northIndicesWestToEast) {
+function TerrainMesh(center, vertices, indices, indexCountWithoutSkirts, vertexCountWithoutSkirts, minimumHeight, maximumHeight, rectangle, boundingSphere3D, occludeePointInScaledSpace, vertexStride, orientedBoundingBox, encoding, westIndicesSouthToNorth, southIndicesEastToWest, eastIndicesNorthToSouth, northIndicesWestToEast) {
   this.center = center;
   this.vertices = vertices;
   this.stride = vertexStride ?? 6;
@@ -1461,6 +2104,7 @@ function TerrainMesh(center, vertices, indices, indexCountWithoutSkirts, vertexC
   this.vertexCountWithoutSkirts = vertexCountWithoutSkirts;
   this.minimumHeight = minimumHeight;
   this.maximumHeight = maximumHeight;
+  this.rectangle = rectangle;
   this.boundingSphere3D = boundingSphere3D;
   this.occludeePointInScaledSpace = occludeePointInScaledSpace;
   this.orientedBoundingBox = orientedBoundingBox;
@@ -1469,7 +2113,116 @@ function TerrainMesh(center, vertices, indices, indexCountWithoutSkirts, vertexC
   this.southIndicesEastToWest = southIndicesEastToWest;
   this.eastIndicesNorthToSouth = eastIndicesNorthToSouth;
   this.northIndicesWestToEast = northIndicesWestToEast;
+  this._transform = new Matrix4_default();
+  this._recomputeTransform = true;
+  this._terrainPicker = new TerrainPicker_default(vertices, indices, encoding);
 }
+TerrainMesh.prototype.getTransform = function(mode, projection) {
+  if (!this._recomputeTransform) {
+    return this._transform;
+  }
+  this._recomputeTransform = false;
+  if (!defined_default(mode) || mode === SceneMode_default.SCENE3D) {
+    return computeTransform(this, this._transform);
+  }
+  return computeTransform2D(this, projection, this._transform);
+};
+function computeTransform(mesh, result) {
+  const exaggeration = mesh.encoding.exaggeration;
+  const exaggerationRelativeHeight = mesh.encoding.exaggerationRelativeHeight;
+  const exaggeratedMinHeight = VerticalExaggeration_default.getHeight(
+    mesh.minimumHeight,
+    exaggeration,
+    exaggerationRelativeHeight
+  );
+  const exaggeratedMaxHeight = VerticalExaggeration_default.getHeight(
+    mesh.maximumHeight,
+    exaggeration,
+    exaggerationRelativeHeight
+  );
+  const obb = OrientedBoundingBox_default.fromRectangle(
+    mesh.rectangle,
+    exaggeratedMinHeight,
+    exaggeratedMaxHeight,
+    Ellipsoid_default.default,
+    mesh.orientedBoundingBox
+  );
+  return OrientedBoundingBox_default.computeTransformation(obb, result);
+}
+var scratchSWCartesian = new Cartesian3_default();
+var scratchNECartesian = new Cartesian3_default();
+var scratchSWCartographic = new Cartographic_default();
+var scratchNECartographic = new Cartographic_default();
+var scratchScale2D = new Cartesian3_default();
+var scratchCenter2D = new Cartesian3_default();
+function computeTransform2D(mesh, projection, result) {
+  const exaggeration = mesh.encoding.exaggeration;
+  const exaggerationRelativeHeight = mesh.encoding.exaggerationRelativeHeight;
+  const exaggeratedMinHeight = VerticalExaggeration_default.getHeight(
+    mesh.minimumHeight,
+    exaggeration,
+    exaggerationRelativeHeight
+  );
+  const exaggeratedMaxHeight = VerticalExaggeration_default.getHeight(
+    mesh.maximumHeight,
+    exaggeration,
+    exaggerationRelativeHeight
+  );
+  const southwest = projection.project(
+    Cartographic_default.fromRadians(
+      mesh.rectangle.west,
+      mesh.rectangle.south,
+      0,
+      scratchSWCartographic
+    ),
+    scratchSWCartesian
+  );
+  const northeast = projection.project(
+    Cartographic_default.fromRadians(
+      mesh.rectangle.east,
+      mesh.rectangle.north,
+      0,
+      scratchNECartographic
+    ),
+    scratchNECartesian
+  );
+  const heightRange = exaggeratedMaxHeight - exaggeratedMinHeight;
+  const scale = Cartesian3_default.fromElements(
+    northeast.x - southwest.x,
+    northeast.y - southwest.y,
+    heightRange > 0 ? heightRange : 1,
+    // Avoid zero scale
+    scratchScale2D
+  );
+  const center = Cartesian3_default.fromElements(
+    southwest.x + scale.x * 0.5,
+    southwest.y + scale.y * 0.5,
+    exaggeratedMinHeight + scale.z * 0.5,
+    scratchCenter2D
+  );
+  Matrix4_default.fromTranslation(center, result);
+  Matrix4_default.setScale(result, scale, result);
+  Matrix4_default.multiply(Transforms_default.SWIZZLE_3D_TO_2D_MATRIX, result, result);
+  return result;
+}
+TerrainMesh.prototype.pick = function(ray, cullBackFaces, mode, projection) {
+  return this._terrainPicker.rayIntersect(
+    ray,
+    this.getTransform(mode, projection),
+    cullBackFaces,
+    mode,
+    projection
+  );
+};
+TerrainMesh.prototype.updateExaggeration = function(exaggeration, exaggerationRelativeHeight) {
+  this._terrainPicker._vertices = this.vertices;
+  this._terrainPicker.needsRebuild = true;
+  this._recomputeTransform = true;
+};
+TerrainMesh.prototype.updateSceneMode = function(mode) {
+  this._terrainPicker.needsRebuild = true;
+  this._recomputeTransform = true;
+};
 var TerrainMesh_default = TerrainMesh;
 
 // packages/engine/Source/Core/Cesium3DTilesTerrainGeometryProcessor.js
@@ -1492,7 +2245,7 @@ var scratchMinimumPositionENU = new Cartesian3_default();
 var scratchMaximumPositionENU = new Cartesian3_default();
 var scratchPosLocal = new Cartesian3_default();
 var scratchPosEcef = new Cartesian3_default();
-var scratchCartographic = new Cartographic_default();
+var scratchCartographic2 = new Cartographic_default();
 var scratchUV = new Cartesian2_default();
 var scratchNormal = new Cartesian3_default();
 var scratchNormalOct = new Cartesian2_default();
@@ -1651,7 +2404,7 @@ Cesium3DTilesTerrainGeometryProcessor.createMesh = async function(options) {
     const cartographic = Cartographic_default.fromCartesian(
       posECEF,
       ellipsoid,
-      scratchCartographic
+      scratchCartographic2
     );
     const { longitude, latitude, height } = cartographic;
     let u = (longitude - tileMinLongitude) / tileLengthLongitude;
@@ -1718,6 +2471,7 @@ Cesium3DTilesTerrainGeometryProcessor.createMesh = async function(options) {
     vertexCountWithoutSkirts,
     minimumHeight,
     maximumHeight,
+    rectangle,
     BoundingSphere_default.clone(boundingSphere, new BoundingSphere_default()),
     Cartesian3_default.clone(horizonOcclusionPoint, new Cartesian3_default()),
     tempBufferStride,
@@ -2218,6 +2972,7 @@ Cesium3DTilesTerrainGeometryProcessor.upsampleMesh = function(options) {
     upsampledVertexCountWithoutSkirts,
     minimumHeight,
     maximumHeight,
+    upsampleRectangle,
     BoundingSphere_default.clone(boundingSphere),
     Cartesian3_default.clone(horizonOcclusionPoint),
     upsampledVertexBufferStride,