@cesium/engine 22.0.0 → 22.1.0

package/Build/Workers/incrementallyBuildTerrainPicker.js

@@ -0,0 +1,121 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.136.0
+ *
+ * Copyright 2011-2022 Cesium Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Columbus View (Pat. Pend.)
+ *
+ * Portions licensed separately.
+ * See https://github.com/CesiumGS/cesium/blob/main/LICENSE.md for full licensing details.
+ */
+
+import {
+  createTaskProcessorWorker_default
+} from "./chunk-2AM4E2WD.js";
+import {
+  AxisAlignedBoundingBox_default
+} from "./chunk-OXFU5HNU.js";
+import "./chunk-23T2IPHV.js";
+import {
+  Matrix4_default
+} from "./chunk-W4XUEDU5.js";
+import "./chunk-5JKH4AMT.js";
+import {
+  Cartesian3_default
+} from "./chunk-3YTMGEXW.js";
+import "./chunk-IL5F6WEE.js";
+import "./chunk-QEANVUGT.js";
+import "./chunk-2RCIRXNI.js";
+
+// packages/engine/Source/Workers/incrementallyBuildTerrainPicker.js
+var scratchAABBCornerMin = new Cartesian3_default();
+var scratchAABBCornerMax = new Cartesian3_default();
+var scratchTrianglePoints = [
+  new Cartesian3_default(),
+  new Cartesian3_default(),
+  new Cartesian3_default()
+];
+var scratchTriangleAABB = new AxisAlignedBoundingBox_default();
+function incrementallyBuildTerrainPicker(parameters, transferableObjects) {
+  const aabbs = new Float64Array(parameters.aabbs);
+  const nodeAABBs = Array.from({ length: 4 }, (_, i) => {
+    const min = Cartesian3_default.unpack(aabbs, i * 6, scratchAABBCornerMin);
+    const max = Cartesian3_default.unpack(aabbs, i * 6 + 3, scratchAABBCornerMax);
+    return AxisAlignedBoundingBox_default.fromCorners(
+      min,
+      max,
+      new AxisAlignedBoundingBox_default()
+    );
+  });
+  const inverseTransformArray = new Float64Array(parameters.inverseTransform);
+  const inverseTransform = Matrix4_default.unpack(
+    inverseTransformArray,
+    0,
+    new Matrix4_default()
+  );
+  const triangleIndices = new Uint32Array(parameters.triangleIndices);
+  const trianglePositions = new Float32Array(parameters.trianglePositions);
+  const intersectingTrianglesArrays = Array.from({ length: 4 }, () => []);
+  for (let j = 0; j < triangleIndices.length; j++) {
+    Cartesian3_default.unpack(trianglePositions, j * 9, scratchTrianglePoints[0]);
+    Cartesian3_default.unpack(trianglePositions, j * 9 + 3, scratchTrianglePoints[1]);
+    Cartesian3_default.unpack(trianglePositions, j * 9 + 6, scratchTrianglePoints[2]);
+    const triangleAABB = createAABBFromTriangle(
+      inverseTransform,
+      scratchTrianglePoints
+    );
+    for (let i = 0; i < 4; i++) {
+      const aabbsIntersect = nodeAABBs[i].intersectAxisAlignedBoundingBox(triangleAABB);
+      if (!aabbsIntersect) {
+        continue;
+      }
+      intersectingTrianglesArrays[i].push(triangleIndices[j]);
+    }
+  }
+  const intersectingTrianglesTypedArrays = intersectingTrianglesArrays.map(
+    (array) => {
+      const uintArray = new Uint32Array(array);
+      transferableObjects.push(uintArray.buffer);
+      return uintArray.buffer;
+    }
+  );
+  return {
+    intersectingTrianglesArrays: intersectingTrianglesTypedArrays
+  };
+}
+function createAABBFromTriangle(inverseTransform, trianglePoints) {
+  Matrix4_default.multiplyByPoint(
+    inverseTransform,
+    trianglePoints[0],
+    trianglePoints[0]
+  );
+  Matrix4_default.multiplyByPoint(
+    inverseTransform,
+    trianglePoints[1],
+    trianglePoints[1]
+  );
+  Matrix4_default.multiplyByPoint(
+    inverseTransform,
+    trianglePoints[2],
+    trianglePoints[2]
+  );
+  return AxisAlignedBoundingBox_default.fromPoints(trianglePoints, scratchTriangleAABB);
+}
+var incrementallyBuildTerrainPicker_default = createTaskProcessorWorker_default(incrementallyBuildTerrainPicker);
+export {
+  incrementallyBuildTerrainPicker_default as default
+};

package/Build/Workers/transcodeKTX2.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,22 +25,22 @@
 
 import {
   createTaskProcessorWorker_default
-} from "./chunk-VVZ667H6.js";
+} from "./chunk-2AM4E2WD.js";
 import {
   WebGLConstants_default
-} from "./chunk-IGX772ZQ.js";
+} from "./chunk-YSYSXSHF.js";
 import {
   RuntimeError_default
-} from "./chunk-5T5SY63I.js";
+} from "./chunk-5JKH4AMT.js";
 import {
   Check_default
-} from "./chunk-W4PIP5PG.js";
+} from "./chunk-QEANVUGT.js";
 import {
   __commonJS,
   __require,
   __toESM,
   defined_default
-} from "./chunk-75HAJIDT.js";
+} from "./chunk-2RCIRXNI.js";
 
 // packages/engine/Source/ThirdParty/Workers/basis_transcoder.js
 var require_basis_transcoder = __commonJS({

package/Build/Workers/transferTypedArrayTest.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
  *

package/Build/Workers/upsampleQuantizedTerrainMesh.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
  *
@@ -26,48 +26,52 @@
 import {
   EllipsoidalOccluder_default,
   TerrainEncoding_default
-} from "./chunk-P2H75UV5.js";
+} from "./chunk-MKMZHRB3.js";
 import {
   createTaskProcessorWorker_default
-} from "./chunk-VVZ667H6.js";
+} from "./chunk-2AM4E2WD.js";
 import {
   OrientedBoundingBox_default
-} from "./chunk-KGLDJRSO.js";
+} from "./chunk-YF2NVO5B.js";
 import {
   AttributeCompression_default
-} from "./chunk-6HBKE43B.js";
-import "./chunk-U7CX3HHE.js";
-import "./chunk-NGKF5NTR.js";
-import "./chunk-AOM3FHBN.js";
-import "./chunk-N52ZRKUE.js";
+} from "./chunk-RXZDTDIY.js";
+import "./chunk-Z6DFT4D3.js";
+import "./chunk-OXFU5HNU.js";
+import "./chunk-DMEFNTUV.js";
+import "./chunk-4BHWJWS3.js";
 import {
   IndexDatatype_default
-} from "./chunk-H7B7FU2U.js";
+} from "./chunk-A6YFUGJO.js";
 import {
   BoundingSphere_default
-} from "./chunk-MXHRZHDF.js";
+} from "./chunk-GDU4RZSZ.js";
+import "./chunk-23T2IPHV.js";
 import {
   Rectangle_default
-} from "./chunk-3GL53OCU.js";
-import "./chunk-EZ7NJXQN.js";
-import "./chunk-IGX772ZQ.js";
-import "./chunk-5T5SY63I.js";
+} from "./chunk-AOIO5VUS.js";
+import "./chunk-W4XUEDU5.js";
+import "./chunk-I4REFVXB.js";
+import "./chunk-YSYSXSHF.js";
+import "./chunk-5JKH4AMT.js";
 import {
   Cartesian2_default,
-  Cartesian3_default,
   Cartographic_default,
   Ellipsoid_default
-} from "./chunk-RQRODXVN.js";
+} from "./chunk-TDSVSW5A.js";
+import {
+  Cartesian3_default
+} from "./chunk-3YTMGEXW.js";
 import {
   Math_default
-} from "./chunk-OE22564R.js";
+} from "./chunk-IL5F6WEE.js";
 import {
   Check_default,
   DeveloperError_default
-} from "./chunk-W4PIP5PG.js";
+} from "./chunk-QEANVUGT.js";
 import {
   defined_default
-} from "./chunk-75HAJIDT.js";
+} from "./chunk-2RCIRXNI.js";
 
 // packages/engine/Source/Core/Intersections2D.js
 var Intersections2D = {};

package/Build/Workers/upsampleVerticesFromCesium3DTilesTerrain.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,29 +25,32 @@
 
 import {
   Cesium3DTilesTerrainGeometryProcessor_default
-} from "./chunk-7XEJGXX2.js";
-import "./chunk-34YXP222.js";
-import "./chunk-P2H75UV5.js";
+} from "./chunk-WB4TSSBQ.js";
+import "./chunk-HXKUEOOD.js";
+import "./chunk-MKMZHRB3.js";
 import {
   createTaskProcessorWorker_default
-} from "./chunk-VVZ667H6.js";
-import "./chunk-LWJXCI3F.js";
-import "./chunk-KGLDJRSO.js";
-import "./chunk-6HBKE43B.js";
-import "./chunk-U7CX3HHE.js";
-import "./chunk-NGKF5NTR.js";
-import "./chunk-AOM3FHBN.js";
-import "./chunk-N52ZRKUE.js";
-import "./chunk-H7B7FU2U.js";
-import "./chunk-MXHRZHDF.js";
-import "./chunk-3GL53OCU.js";
-import "./chunk-EZ7NJXQN.js";
-import "./chunk-IGX772ZQ.js";
-import "./chunk-5T5SY63I.js";
-import "./chunk-RQRODXVN.js";
-import "./chunk-OE22564R.js";
-import "./chunk-W4PIP5PG.js";
-import "./chunk-75HAJIDT.js";
+} from "./chunk-2AM4E2WD.js";
+import "./chunk-H6Q7E4BQ.js";
+import "./chunk-YF2NVO5B.js";
+import "./chunk-RXZDTDIY.js";
+import "./chunk-Z6DFT4D3.js";
+import "./chunk-OXFU5HNU.js";
+import "./chunk-DMEFNTUV.js";
+import "./chunk-4BHWJWS3.js";
+import "./chunk-A6YFUGJO.js";
+import "./chunk-GDU4RZSZ.js";
+import "./chunk-23T2IPHV.js";
+import "./chunk-AOIO5VUS.js";
+import "./chunk-W4XUEDU5.js";
+import "./chunk-I4REFVXB.js";
+import "./chunk-YSYSXSHF.js";
+import "./chunk-5JKH4AMT.js";
+import "./chunk-TDSVSW5A.js";
+import "./chunk-3YTMGEXW.js";
+import "./chunk-IL5F6WEE.js";
+import "./chunk-QEANVUGT.js";
+import "./chunk-2RCIRXNI.js";
 
 // packages/engine/Source/Workers/upsampleVerticesFromCesium3DTilesTerrain.js
 function upsampleVerticesFromCesium3DTilesTerrain(options, transferableObjects) {

package/Source/Core/AxisAlignedBoundingBox.js

@@ -222,6 +222,30 @@ AxisAlignedBoundingBox.intersectPlane = function (box, plane) {
   return Intersect.INTERSECTING;
 };
 
+/**
+ * Determines whether two axis aligned bounding boxes intersect.
+ *
+ * @param {AxisAlignedBoundingBox} box first box
+ * @param {AxisAlignedBoundingBox} other second box
+ * @returns {boolean} <code>true</code> if the boxes intersect; otherwise, <code>false</code>.
+ */
+AxisAlignedBoundingBox.intersectAxisAlignedBoundingBox = function (box, other) {
+  //>>includeStart('debug', pragmas.debug);
+  Check.defined("box", box);
+  Check.defined("other", other);
+  //>>includeEnd('debug');
+
+  // This short circuits in favor of AABBs that do not intersect.
+  return (
+    box.minimum.x <= other.maximum.x &&
+    box.maximum.x >= other.minimum.x &&
+    box.minimum.y <= other.maximum.y &&
+    box.maximum.y >= other.minimum.y &&
+    box.minimum.z <= other.maximum.z &&
+    box.maximum.z >= other.minimum.z
+  );
+};
+
 /**
  * Duplicates this AxisAlignedBoundingBox instance.
  *
@@ -245,6 +269,18 @@ AxisAlignedBoundingBox.prototype.intersectPlane = function (plane) {
   return AxisAlignedBoundingBox.intersectPlane(this, plane);
 };
 
+/**
+ * Determines whether some other axis aligned bounding box intersects this box.
+ *
+ * @param {AxisAlignedBoundingBox} other The other axis aligned bounding box.
+ * @returns {boolean} <code>true</code> if the boxes intersect; otherwise, <code>false</code>.
+ */
+AxisAlignedBoundingBox.prototype.intersectAxisAlignedBoundingBox = function (
+  other,
+) {
+  return AxisAlignedBoundingBox.intersectAxisAlignedBoundingBox(this, other);
+};
+
 /**
  * Compares this AxisAlignedBoundingBox against the provided AxisAlignedBoundingBox componentwise and returns
  * <code>true</code> if they are equal, <code>false</code> otherwise.

package/Source/Core/Cesium3DTilesTerrainData.js

@@ -305,6 +305,7 @@ Cesium3DTilesTerrainData.prototype.createMesh = function (options) {
       vertexCountWithoutSkirts,
       minimumHeight,
       maximumHeight,
+      rectangle,
       boundingSphere,
       horizonOcclusionPoint,
       encoding.stride,
@@ -831,6 +832,7 @@ function upsampleMesh(
       vertexCountWithoutSkirts,
       minimumHeight,
       maximumHeight,
+      upsampleRectangle,
       boundingSphere,
       horizonOcclusionPoint,
       stride,

package/Source/Core/Cesium3DTilesTerrainGeometryProcessor.js

@@ -384,6 +384,7 @@ Cesium3DTilesTerrainGeometryProcessor.createMesh = async function (options) {
     vertexCountWithoutSkirts,
     minimumHeight,
     maximumHeight,
+    rectangle,
     BoundingSphere.clone(boundingSphere, new BoundingSphere()),
     Cartesian3.clone(horizonOcclusionPoint, new Cartesian3()),
     tempBufferStride,
@@ -1063,6 +1064,7 @@ Cesium3DTilesTerrainGeometryProcessor.upsampleMesh = function (options) {
     upsampledVertexCountWithoutSkirts,
     minimumHeight,
     maximumHeight,
+    upsampleRectangle,
     BoundingSphere.clone(boundingSphere),
     Cartesian3.clone(horizonOcclusionPoint),
     upsampledVertexBufferStride,

package/Source/Core/GoogleEarthEnterpriseTerrainData.js

@@ -210,6 +210,7 @@ GoogleEarthEnterpriseTerrainData.prototype.createMesh = function (options) {
       result.vertexCountWithoutSkirts,
       result.minimumHeight,
       result.maximumHeight,
+      rectangleScratch,
       BoundingSphere.clone(result.boundingSphere3D),
       Cartesian3.clone(result.occludeePointInScaledSpace),
       result.numberOfAttributes,

package/Source/Core/HeightmapTerrainData.js

@@ -283,6 +283,7 @@ HeightmapTerrainData.prototype.createMesh = function (options) {
       vertexCountWithoutSkirts,
       result.minimumHeight,
       result.maximumHeight,
+      rectangle,
       BoundingSphere.clone(result.boundingSphere3D),
       Cartesian3.clone(result.occludeePointInScaledSpace),
       result.numberOfAttributes,
@@ -389,6 +390,7 @@ HeightmapTerrainData.prototype._createMeshSync = function (options) {
     vertexCountWithoutSkirts,
     result.minimumHeight,
     result.maximumHeight,
+    rectangle,
     result.boundingSphere3D,
     result.occludeePointInScaledSpace,
     result.encoding.stride,

package/Source/Core/IntersectionTests.js

@@ -495,6 +495,86 @@ IntersectionTests.rayEllipsoid = function (ray, ellipsoid) {
   return undefined;
 };
 
+const scratchRayIntervalX = new Interval();
+const scratchRayIntervalY = new Interval();
+const scratchRayIntervalZ = new Interval();
+
+/**
+ * Computes the intersection points of a ray with an axis-aligned bounding box. (axis-aligned in the same space as the ray)
+ *
+ * @param {Ray} ray The ray.
+ * @param {AxisAlignedBoundingBox} box The axis-aligned bounding box.
+ * @param {Interval | undefined} result The interval containing scalar points along the ray or undefined if there are no intersections.
+ */
+IntersectionTests.rayAxisAlignedBoundingBox = function (ray, box, result) {
+  //>>includeStart('debug', pragmas.debug);
+  if (!defined(ray)) {
+    throw new DeveloperError("ray is required.");
+  }
+  if (!defined(box)) {
+    throw new DeveloperError("box is required.");
+  }
+  //>>includeEnd('debug');
+
+  if (!defined(result)) {
+    result = new Interval();
+  }
+
+  const tx = rayIntervalAlongAABBAxis(
+    ray.origin.x,
+    ray.direction.x,
+    box.minimum.x,
+    box.maximum.x,
+    scratchRayIntervalX,
+  );
+  const ty = rayIntervalAlongAABBAxis(
+    ray.origin.y,
+    ray.direction.y,
+    box.minimum.y,
+    box.maximum.y,
+    scratchRayIntervalY,
+  );
+  const tz = rayIntervalAlongAABBAxis(
+    ray.origin.z,
+    ray.direction.z,
+    box.minimum.z,
+    box.maximum.z,
+    scratchRayIntervalZ,
+  );
+
+  result.start = tx.start > ty.start ? tx.start : ty.start; //Get Greatest Min
+  result.stop = tx.stop < ty.stop ? tx.stop : ty.stop; //Get Smallest Max
+
+  if (tx.start > ty.stop || ty.start > tx.stop) {
+    return undefined;
+  }
+
+  if (result.start > tz.stop || tz.start > result.stop) {
+    return undefined;
+  }
+
+  if (tz.start > result.start) {
+    result.start = tz.start;
+  }
+  if (tz.stop < result.stop) {
+    result.stop = tz.stop;
+  }
+
+  return result;
+};
+
+function rayIntervalAlongAABBAxis(origin, direction, min, max, result) {
+  result.start = (min - origin) / direction;
+  result.stop = (max - origin) / direction;
+  if (result.stop < result.start) {
+    const tmp = result.stop;
+    result.stop = result.start;
+    result.start = tmp;
+  }
+
+  return result;
+}
+
 function addWithCancellationCheck(left, right, tolerance) {
   const difference = left + right;
   if (

package/Source/Core/Ion.js

@@ -4,7 +4,7 @@ import Resource from "./Resource.js";
 
 let defaultTokenCredit;
 const defaultAccessToken =
-  "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiJhN2VkNDM5ZS1jMDk0LTQ3NDItOTM5ZS00MzU3M2M1MTc2ZTkiLCJpZCI6MjU5LCJpYXQiOjE3NjIxODg4MDB9.ZZG574sONzeHxsX8HJMaL_ZiGA3dh_HrOxL7DrKRcd4";
+  "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiIxYTBmZmMzNy02NzcxLTRiMjUtYTllZS1hZmJjY2RkYjVhY2UiLCJpZCI6MjU5LCJpYXQiOjE3NjQ2MDU5OTB9.Nefln7pgRwDffoCJRJ8aaZn5iQzIPQrboLwKD2-ArDU";
 /**
  * Default settings for accessing the Cesium ion API.
  *

package/Source/Core/QuantizedMeshTerrainData.js

@@ -349,6 +349,7 @@ QuantizedMeshTerrainData.prototype.createMesh = function (options) {
       vertexCountWithoutSkirts,
       minimumHeight,
       maximumHeight,
+      rectangle,
       boundingSphere,
       occludeePointInScaledSpace,
       stride,