@cesium/engine 16.0.0 → 17.0.0

package/Source/Scene/Cesium3DTilesVoxelProvider.js

@@ -9,6 +9,7 @@ import ImplicitSubtree from "./ImplicitSubtree.js";
 import ImplicitSubtreeCache from "./ImplicitSubtreeCache.js";
 import ImplicitTileCoordinates from "./ImplicitTileCoordinates.js";
 import ImplicitTileset from "./ImplicitTileset.js";
+import Matrix3 from "../Core/Matrix3.js";
 import Matrix4 from "../Core/Matrix4.js";
 import MetadataSemantic from "./MetadataSemantic.js";
 import MetadataType from "./MetadataType.js";
@@ -17,7 +18,6 @@ import preprocess3DTileContent from "./preprocess3DTileContent.js";
 import Resource from "../Core/Resource.js";
 import ResourceCache from "./ResourceCache.js";
 import RuntimeError from "../Core/RuntimeError.js";
-import VoxelBoxShape from "./VoxelBoxShape.js";
 import VoxelContent from "./VoxelContent.js";
 import VoxelMetadataOrder from "./VoxelMetadataOrder.js";
 import VoxelShapeType from "./VoxelShapeType.js";
@@ -411,6 +411,11 @@ Cesium3DTilesVoxelProvider.fromUrl = async function (url) {
 
   const providerOptions = getAttributeInfo(tilesetMetadata, className);
   Object.assign(providerOptions, getShape(root));
+  if (defined(root.transform)) {
+    providerOptions.globalTransform = Matrix4.unpack(root.transform);
+  } else {
+    providerOptions.globalTransform = Matrix4.clone(Matrix4.IDENTITY);
+  }
 
   providerOptions.dimensions = Cartesian3.unpack(voxel.dimensions);
   providerOptions.maximumTileCount = getTileCount(tilesetMetadata);
@@ -477,21 +482,13 @@ function validate(tileset) {
 function getShape(tile) {
   const boundingVolume = tile.boundingVolume;
 
-  let tileTransform;
-  if (defined(tile.transform)) {
-    tileTransform = Matrix4.unpack(tile.transform);
-  } else {
-    tileTransform = Matrix4.clone(Matrix4.IDENTITY);
-  }
-
   if (defined(boundingVolume.box)) {
-    return getBoxShape(boundingVolume.box, tileTransform);
+    return getBoxShape(boundingVolume.box);
   } else if (defined(boundingVolume.region)) {
     return getEllipsoidShape(boundingVolume.region);
   } else if (hasExtension(boundingVolume, "3DTILES_bounding_volume_cylinder")) {
     return getCylinderShape(
       boundingVolume.extensions["3DTILES_bounding_volume_cylinder"],
-      tileTransform,
     );
   }
 
@@ -518,27 +515,26 @@ function getEllipsoidShape(region) {
     minBounds: minBounds,
     maxBounds: maxBounds,
     shapeTransform: shapeTransform,
-    globalTransform: Matrix4.clone(Matrix4.IDENTITY),
   };
 }
 
-function getBoxShape(box, tileTransform) {
+const scratchScale = new Cartesian3();
+const scratchRotation = new Matrix3();
+
+function getBoxShape(box) {
   const obb = OrientedBoundingBox.unpack(box);
-  const shapeTransform = Matrix4.fromRotationTranslation(
-    obb.halfAxes,
-    obb.center,
-  );
+  const scale = Matrix3.getScale(obb.halfAxes, scratchScale);
+  const rotation = Matrix3.getRotation(obb.halfAxes, scratchRotation);
 
   return {
     shape: VoxelShapeType.BOX,
-    minBounds: Cartesian3.clone(VoxelBoxShape.DefaultMinBounds),
-    maxBounds: Cartesian3.clone(VoxelBoxShape.DefaultMaxBounds),
-    shapeTransform: shapeTransform,
-    globalTransform: tileTransform,
+    minBounds: Cartesian3.negate(scale, new Cartesian3()),
+    maxBounds: Cartesian3.clone(scale),
+    shapeTransform: Matrix4.fromRotationTranslation(rotation, obb.center),
   };
 }
 
-function getCylinderShape(cylinder, tileTransform) {
+function getCylinderShape(cylinder) {
   const {
     minRadius,
     maxRadius,
@@ -565,7 +561,7 @@ function getCylinderShape(cylinder, tileTransform) {
   const shapeTransform = Matrix4.fromTranslationQuaternionRotationScale(
     Cartesian3.unpack(translation),
     Quaternion.unpack(rotation),
-    new Cartesian3(maxRadius, maxRadius, 0.5 * height),
+    Cartesian3.ONE,
   );
 
   return {
@@ -573,7 +569,6 @@ function getCylinderShape(cylinder, tileTransform) {
     minBounds: Cartesian3.fromElements(minRadius, minAngle, minHeight),
     maxBounds: Cartesian3.fromElements(maxRadius, maxAngle, maxHeight),
     shapeTransform: shapeTransform,
-    globalTransform: tileTransform,
   };
 }
 

package/Source/Scene/ImageryLayer.js

@@ -85,7 +85,7 @@ import TileImagery from "./TileImagery.js";
  *                          <code>function(frameState, layer, x, y, level)</code>.  The function is passed the
  *                          current frame state, this layer, and the x, y, and level coordinates
  *                          of the imagery tile for which the hue is required, and it is expected to return
- *                          the contrast value to use for the tile.  The function is executed for every
+ *                          the hue value to use for the tile.  The function is executed for every
  *                          frame and for every tile, so it must be fast.
  * @property {number|Function} [saturation=1.0] The saturation of this layer.  1.0 uses the unmodified imagery color.
  *                          Less than 1.0 reduces the saturation while greater than 1.0 increases it.
@@ -93,7 +93,7 @@ import TileImagery from "./TileImagery.js";
  *                          <code>function(frameState, layer, x, y, level)</code>.  The function is passed the
  *                          current frame state, this layer, and the x, y, and level coordinates
  *                          of the imagery tile for which the saturation is required, and it is expected to return
- *                          the contrast value to use for the tile.  The function is executed for every
+ *                          the saturation value to use for the tile.  The function is executed for every
  *                          frame and for every tile, so it must be fast.
  * @property {number|Function} [gamma=1.0] The gamma correction to apply to this layer.  1.0 uses the unmodified imagery color.
  *                          This can either be a simple number or a function with the signature

package/Source/Scene/QuadtreePrimitive.js

@@ -1526,7 +1526,11 @@ function updateHeights(primitive, frameState) {
         }
         if (defined(position)) {
           if (defined(data.callback)) {
-            data.callback(position);
+            const positionCarto = ellipsoid.cartesianToCartographic(
+              position,
+              scratchCartographic,
+            );
+            data.callback(positionCarto);
           }
           data.level = tile.level;
         }

package/Source/Scene/VoxelBoxShape.js

@@ -57,22 +57,18 @@ function VoxelBoxShape() {
   this.shapeTransform = new Matrix4();
 
   /**
+   * The minimum bounds of the shape.
    * @type {Cartesian3}
    * @private
    */
-  this._minBounds = Cartesian3.clone(
-    VoxelBoxShape.DefaultMinBounds,
-    new Cartesian3(),
-  );
+  this._minBounds = VoxelBoxShape.DefaultMinBounds.clone();
 
   /**
+   * The maximum bounds of the shape.
    * @type {Cartesian3}
    * @private
    */
-  this._maxBounds = Cartesian3.clone(
-    VoxelBoxShape.DefaultMaxBounds,
-    new Cartesian3(),
-  );
+  this._maxBounds = VoxelBoxShape.DefaultMaxBounds.clone();
 
   /**
    * @private
@@ -125,8 +121,8 @@ const transformLocalToUv = Matrix4.fromRotationTranslation(
  * @param {Matrix4} modelMatrix The model matrix.
  * @param {Cartesian3} minBounds The minimum bounds.
  * @param {Cartesian3} maxBounds The maximum bounds.
- * @param {Cartesian3} [clipMinBounds=VoxelBoxShape.DefaultMinBounds] The minimum clip bounds.
- * @param {Cartesian3} [clipMaxBounds=VoxelBoxShape.DefaultMaxBounds] The maximum clip bounds.
+ * @param {Cartesian3} [clipMinBounds] The minimum clip bounds.
+ * @param {Cartesian3} [clipMaxBounds] The maximum clip bounds.
  * @returns {boolean} Whether the shape is visible.
  */
 VoxelBoxShape.prototype.update = function (
@@ -136,44 +132,17 @@ VoxelBoxShape.prototype.update = function (
   clipMinBounds,
   clipMaxBounds,
 ) {
-  clipMinBounds = clipMinBounds ?? VoxelBoxShape.DefaultMinBounds;
-  clipMaxBounds = clipMaxBounds ?? VoxelBoxShape.DefaultMaxBounds;
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.object("modelMatrix", modelMatrix);
   Check.typeOf.object("minBounds", minBounds);
   Check.typeOf.object("maxBounds", maxBounds);
   //>>includeEnd('debug');
 
-  const defaultMinBounds = VoxelBoxShape.DefaultMinBounds;
-  const defaultMaxBounds = VoxelBoxShape.DefaultMaxBounds;
+  clipMinBounds = clipMinBounds ?? minBounds.clone(scratchClipMinBounds);
+  clipMaxBounds = clipMaxBounds ?? maxBounds.clone(scratchClipMaxBounds);
 
-  minBounds = this._minBounds = Cartesian3.clamp(
-    minBounds,
-    defaultMinBounds,
-    defaultMaxBounds,
-    this._minBounds,
-  );
-
-  maxBounds = this._maxBounds = Cartesian3.clamp(
-    maxBounds,
-    defaultMinBounds,
-    defaultMaxBounds,
-    this._maxBounds,
-  );
-
-  clipMinBounds = Cartesian3.clamp(
-    clipMinBounds,
-    defaultMinBounds,
-    defaultMaxBounds,
-    scratchClipMinBounds,
-  );
-
-  clipMaxBounds = Cartesian3.clamp(
-    clipMaxBounds,
-    defaultMinBounds,
-    defaultMaxBounds,
-    scratchClipMaxBounds,
-  );
+  minBounds = Cartesian3.clone(minBounds, this._minBounds);
+  maxBounds = Cartesian3.clone(maxBounds, this._maxBounds);
 
   const renderMinBounds = Cartesian3.clamp(
     minBounds,
@@ -181,7 +150,6 @@ VoxelBoxShape.prototype.update = function (
     clipMaxBounds,
     scratchRenderMinBounds,
   );
-
   const renderMaxBounds = Cartesian3.clamp(
     maxBounds,
     clipMinBounds,
@@ -189,13 +157,11 @@ VoxelBoxShape.prototype.update = function (
     scratchRenderMaxBounds,
   );
 
-  const scale = Matrix4.getScale(modelMatrix, scratchScale);
-
   // Box is not visible if:
   // - any of the min render bounds exceed the max render bounds
   // - two or more of the min bounds equal the max bounds (line / point)
-  // - any of the min clip bounds exceed the max clip bounds
   // - scale is 0 for any component (too annoying to reconstruct rotation matrix)
+  const scale = Matrix4.getScale(modelMatrix, scratchScale);
   if (
     renderMinBounds.x > renderMaxBounds.x ||
     renderMinBounds.y > renderMaxBounds.y ||
@@ -204,9 +170,6 @@ VoxelBoxShape.prototype.update = function (
       (renderMinBounds.y === renderMaxBounds.y) +
       (renderMinBounds.z === renderMaxBounds.z) >=
       2 ||
-    clipMinBounds.x > clipMaxBounds.x ||
-    clipMinBounds.y > clipMaxBounds.y ||
-    clipMinBounds.z > clipMaxBounds.z ||
     scale.x === 0.0 ||
     scale.y === 0.0 ||
     scale.z === 0.0
@@ -245,10 +208,6 @@ VoxelBoxShape.prototype.update = function (
     }
   }
 
-  const hasShapeBounds =
-    !Cartesian3.equals(minBounds, defaultMinBounds) ||
-    !Cartesian3.equals(maxBounds, defaultMaxBounds);
-
   // Keep track of how many intersections there are going to be.
   let intersectionCount = 0;
 
@@ -266,36 +225,34 @@ VoxelBoxShape.prototype.update = function (
     shaderUniforms.renderMaxBounds,
   );
 
-  if (hasShapeBounds) {
-    shaderDefines["BOX_HAS_SHAPE_BOUNDS"] = true;
-
-    const min = minBounds;
-    const max = maxBounds;
-
-    // Go from UV space to bounded UV space:
-    // delerp(posUv, minBoundsUv, maxBoundsUv)
-    // (posUv - minBoundsUv) / (maxBoundsUv - minBoundsUv)
-    // posUv / (maxBoundsUv - minBoundsUv) - minBoundsUv / (maxBoundsUv - minBoundsUv)
-    // scale = 1.0 / (maxBoundsUv - minBoundsUv)
-    // scale = 1.0 / ((maxBounds * 0.5 + 0.5) - (minBounds * 0.5 + 0.5))
-    // scale = 2.0 / (maxBounds - minBounds)
-    // offset = -minBoundsUv / ((maxBounds * 0.5 + 0.5) - (minBounds * 0.5 + 0.5))
-    // offset = -2.0 * (minBounds * 0.5 + 0.5) / (maxBounds - minBounds)
-    // offset = -scale * (minBounds * 0.5 + 0.5)
-    shaderUniforms.boxUvToShapeUvScale = Cartesian3.fromElements(
-      2.0 / (min.x === max.x ? 1.0 : max.x - min.x),
-      2.0 / (min.y === max.y ? 1.0 : max.y - min.y),
-      2.0 / (min.z === max.z ? 1.0 : max.z - min.z),
-      shaderUniforms.boxUvToShapeUvScale,
-    );
+  shaderDefines["BOX_HAS_SHAPE_BOUNDS"] = true;
+
+  const min = minBounds;
+  const max = maxBounds;
+
+  // Go from UV space to bounded UV space:
+  // delerp(posUv, minBoundsUv, maxBoundsUv)
+  // (posUv - minBoundsUv) / (maxBoundsUv - minBoundsUv)
+  // posUv / (maxBoundsUv - minBoundsUv) - minBoundsUv / (maxBoundsUv - minBoundsUv)
+  // scale = 1.0 / (maxBoundsUv - minBoundsUv)
+  // scale = 1.0 / ((maxBounds * 0.5 + 0.5) - (minBounds * 0.5 + 0.5))
+  // scale = 2.0 / (maxBounds - minBounds)
+  // offset = -minBoundsUv / ((maxBounds * 0.5 + 0.5) - (minBounds * 0.5 + 0.5))
+  // offset = -2.0 * (minBounds * 0.5 + 0.5) / (maxBounds - minBounds)
+  // offset = -scale * (minBounds * 0.5 + 0.5)
+  shaderUniforms.boxUvToShapeUvScale = Cartesian3.fromElements(
+    2.0 / (min.x === max.x ? 1.0 : max.x - min.x),
+    2.0 / (min.y === max.y ? 1.0 : max.y - min.y),
+    2.0 / (min.z === max.z ? 1.0 : max.z - min.z),
+    shaderUniforms.boxUvToShapeUvScale,
+  );
 
-    shaderUniforms.boxUvToShapeUvTranslate = Cartesian3.fromElements(
-      -shaderUniforms.boxUvToShapeUvScale.x * (min.x * 0.5 + 0.5),
-      -shaderUniforms.boxUvToShapeUvScale.y * (min.y * 0.5 + 0.5),
-      -shaderUniforms.boxUvToShapeUvScale.z * (min.z * 0.5 + 0.5),
-      shaderUniforms.boxUvToShapeUvTranslate,
-    );
-  }
+  shaderUniforms.boxUvToShapeUvTranslate = Cartesian3.fromElements(
+    -shaderUniforms.boxUvToShapeUvScale.x * (min.x * 0.5 + 0.5),
+    -shaderUniforms.boxUvToShapeUvScale.y * (min.y * 0.5 + 0.5),
+    -shaderUniforms.boxUvToShapeUvScale.z * (min.z * 0.5 + 0.5),
+    shaderUniforms.boxUvToShapeUvTranslate,
+  );
 
   this.shaderMaximumIntersectionsLength = intersectionCount;