@cesium/engine 6.2.0 → 8.0.0

package/Source/Scene/VoxelCell.js

@@ -0,0 +1,273 @@
+import Cartesian3 from "../Core/Cartesian3.js";
+import Check from "../Core/Check.js";
+import defined from "../Core/defined.js";
+import MetadataType from "./MetadataType.js";
+import OrientedBoundingBox from "../Core/OrientedBoundingBox.js";
+
+/**
+ * A cell from a {@link VoxelPrimitive}.
+ * <p>
+ * Provides access to properties associated with one cell of a voxel primitive.
+ * </p>
+ * <p>
+ * Do not construct this directly.  Access it through picking using {@link Scene#pickVoxel}.
+ * </p>
+ *
+ * @alias VoxelCell
+ * @constructor
+ *
+ * @param {VoxelPrimitive} primitive The voxel primitive containing the cell
+ * @param {number} tileIndex The index of the tile
+ * @param {number} sampleIndex The index of the sample within the tile, containing metadata for this cell
+ *
+ * @example
+ * // On left click, display all the properties for a voxel cell in the console log.
+ * handler.setInputAction(function(movement) {
+ *   const voxelCell = scene.pickVoxel(movement.position);
+ *   if (voxelCell instanceof Cesium.VoxelCell) {
+ *     const propertyIds = voxelCell.getPropertyIds();
+ *     const length = propertyIds.length;
+ *     for (let i = 0; i < length; ++i) {
+ *       const propertyId = propertyIds[i];
+ *       console.log(`{propertyId}: ${voxelCell.getProperty(propertyId)}`);
+ *     }
+ *   }
+ * }, Cesium.ScreenSpaceEventType.LEFT_CLICK);
+ *
+ * @experimental This feature is not final and is subject to change without Cesium's standard deprecation policy.
+ */
+function VoxelCell(primitive, tileIndex, sampleIndex) {
+  this._primitive = primitive;
+  this._tileIndex = tileIndex;
+  this._sampleIndex = sampleIndex;
+  this._metadata = {};
+  this._orientedBoundingBox = new OrientedBoundingBox();
+}
+
+/**
+ * Construct a VoxelCell, and update the metadata and bounding box using the properties
+ * of a supplied keyframe node.
+ *
+ * @private
+ * @param {VoxelPrimitive} primitive The voxel primitive containing the cell.
+ * @param {number} tileIndex The index of the tile.
+ * @param {number} sampleIndex The index of the sample within the tile, containing metadata for this cell.
+ * @param {KeyframeNode} keyframeNode The keyframe node containing information about the tile.
+ * @returns {VoxelCell}
+ *
+ * @experimental This feature is not final and is subject to change without Cesium's standard deprecation policy.
+ */
+VoxelCell.fromKeyframeNode = function (
+  primitive,
+  tileIndex,
+  sampleIndex,
+  keyframeNode
+) {
+  //>>includeStart('debug', pragmas.debug);
+  Check.typeOf.object("primitive", primitive);
+  Check.typeOf.number("tileIndex", tileIndex);
+  Check.typeOf.number("sampleIndex", sampleIndex);
+  Check.typeOf.object("keyframeNode", keyframeNode);
+  //>>includeEnd('debug');
+
+  const voxelCell = new VoxelCell(primitive, tileIndex, sampleIndex);
+  const { spatialNode, metadata } = keyframeNode;
+  voxelCell._metadata = getMetadataForSample(primitive, metadata, sampleIndex);
+  voxelCell._orientedBoundingBox = getOrientedBoundingBox(
+    primitive,
+    spatialNode,
+    sampleIndex,
+    voxelCell._orientedBoundingBox
+  );
+  return voxelCell;
+};
+
+/**
+ * @private
+ * @param {VoxelPrimitive} primitive
+ * @param {object} metadata
+ * @param {number} sampleIndex
+ * @returns {object}
+ */
+function getMetadataForSample(primitive, metadata, sampleIndex) {
+  if (!defined(metadata)) {
+    return undefined;
+  }
+  const { names, types } = primitive.provider;
+  const metadataMap = {};
+  for (let i = 0; i < names.length; i++) {
+    const name = names[i];
+    const componentCount = MetadataType.getComponentCount(types[i]);
+    const samples = metadata[i].slice(
+      sampleIndex * componentCount,
+      (sampleIndex + 1) * componentCount
+    );
+    metadataMap[name] = samples;
+  }
+  return metadataMap;
+}
+
+const tileCoordinateScratch = new Cartesian3();
+const tileUvScratch = new Cartesian3();
+
+/**
+ * @private
+ * @param {VoxelPrimitive} primitive
+ * @param {SpatialNode} spatialNode
+ * @param {OrientedBoundingBox} result
+ * @returns {OrientedBoundingBox}
+ */
+function getOrientedBoundingBox(primitive, spatialNode, sampleIndex, result) {
+  // Convert the sample index into a 3D tile coordinate
+  // Note: dimensions from the spatialNode include padding
+  const paddedDimensions = spatialNode.dimensions;
+  const sliceSize = paddedDimensions.x * paddedDimensions.y;
+  const zIndex = Math.floor(sampleIndex / sliceSize);
+  const indexInSlice = sampleIndex - zIndex * sliceSize;
+  const yIndex = Math.floor(indexInSlice / paddedDimensions.x);
+  const xIndex = indexInSlice - yIndex * paddedDimensions.x;
+  const tileCoordinate = Cartesian3.fromElements(
+    xIndex,
+    yIndex,
+    zIndex,
+    tileCoordinateScratch
+  );
+
+  // Remove padding, and convert to a fraction in [0, 1], where the limits are
+  // the unpadded bounds of the tile
+  const tileUv = Cartesian3.divideComponents(
+    Cartesian3.subtract(
+      tileCoordinate,
+      primitive._paddingBefore,
+      tileCoordinateScratch
+    ),
+    primitive.dimensions,
+    tileUvScratch
+  );
+
+  const shape = primitive._shape;
+  return shape.computeOrientedBoundingBoxForSample(
+    spatialNode,
+    primitive.dimensions,
+    tileUv,
+    result
+  );
+}
+
+Object.defineProperties(VoxelCell.prototype, {
+  /**
+   * Gets an object of the metadata values for this cell. The object's keys are the metadata names.
+   *
+   * @memberof VoxelCell.prototype
+   *
+   * @type {object}
+   *
+   * @readonly
+   * @private
+   */
+  metadata: {
+    get: function () {
+      return this._metadata;
+    },
+  },
+
+  /**
+   * All objects returned by {@link Scene#pick} have a <code>primitive</code> property. This returns
+   * the VoxelPrimitive containing the cell.
+   *
+   * @memberof VoxelCell.prototype
+   *
+   * @type {VoxelPrimitive}
+   *
+   * @readonly
+   */
+  primitive: {
+    get: function () {
+      return this._primitive;
+    },
+  },
+
+  /**
+   * Get the sample index of the cell.
+   *
+   * @memberof VoxelCell.prototype
+   *
+   * @type {number}
+   *
+   * @readonly
+   */
+  sampleIndex: {
+    get: function () {
+      return this._sampleIndex;
+    },
+  },
+
+  /**
+   * Get the index of the tile containing the cell.
+   *
+   * @memberof VoxelCell.prototype
+   *
+   * @type {number}
+   *
+   * @readonly
+   */
+  tileIndex: {
+    get: function () {
+      return this._tileIndex;
+    },
+  },
+
+  /**
+   * Get a copy of the oriented bounding box containing the cell.
+   *
+   * @memberof VoxelCell.prototype
+   *
+   * @type {OrientedBoundingBox}
+   *
+   * @readonly
+   */
+  orientedBoundingBox: {
+    get: function () {
+      return this._orientedBoundingBox.clone();
+    },
+  },
+});
+
+/**
+ * Returns <code>true</code> if the feature contains this property.
+ *
+ * @param {string} name The case-sensitive name of the property.
+ * @returns {boolean} Whether the feature contains this property.
+ */
+VoxelCell.prototype.hasProperty = function (name) {
+  return defined(this._metadata[name]);
+};
+
+/**
+ * Returns an array of metadata property names for the feature.
+ *
+ * @returns {string[]} The IDs of the feature's properties.
+ */
+VoxelCell.prototype.getNames = function () {
+  return Object.keys(this._metadata);
+};
+
+/**
+ * Returns a copy of the value of the metadata in the cell with the given name.
+ *
+ * @param {string} name The case-sensitive name of the property.
+ * @returns {*} The value of the property or <code>undefined</code> if the feature does not have this property.
+ *
+ * @example
+ * // Display all the properties for a voxel cell in the console log.
+ * const names = voxelCell.getNames();
+ * for (let i = 0; i < names.length; ++i) {
+ *   const name = names[i];
+ *   console.log(`{name}: ${voxelCell.getProperty(name)}`);
+ * }
+ */
+VoxelCell.prototype.getProperty = function (name) {
+  return this._metadata[name];
+};
+
+export default VoxelCell;

package/Source/Scene/VoxelCylinderShape.js

@@ -120,15 +120,11 @@ function VoxelCylinderShape() {
     CYLINDER_HAS_RENDER_BOUNDS_ANGLE: undefined,
     CYLINDER_HAS_RENDER_BOUNDS_ANGLE_RANGE_EQUAL_ZERO: undefined,
     CYLINDER_HAS_RENDER_BOUNDS_ANGLE_RANGE_UNDER_HALF: undefined,
-    CYLINDER_HAS_RENDER_BOUNDS_ANGLE_RANGE_EQUAL_HALF: undefined,
     CYLINDER_HAS_RENDER_BOUNDS_ANGLE_RANGE_OVER_HALF: undefined,
 
     CYLINDER_HAS_SHAPE_BOUNDS_RADIUS: undefined,
-    CYLINDER_HAS_SHAPE_BOUNDS_RADIUS_FLAT: undefined,
     CYLINDER_HAS_SHAPE_BOUNDS_HEIGHT: undefined,
-    CYLINDER_HAS_SHAPE_BOUNDS_HEIGHT_FLAT: undefined,
     CYLINDER_HAS_SHAPE_BOUNDS_ANGLE: undefined,
-    CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_RANGE_EQUAL_ZERO: undefined,
     CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_MIN_DISCONTINUITY: undefined,
     CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_MAX_DISCONTINUITY: undefined,
     CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_MIN_MAX_REVERSED: undefined,
@@ -324,17 +320,12 @@ VoxelCylinderShape.prototype.update = function (
     shapeAngleRange > defaultAngleRangeHalf + epsilonAngle &&
     shapeAngleRange < defaultAngleRange - epsilonAngle;
   const shapeIsAngleFlipped =
-    shapeAngleRange > epsilonAngle &&
     shapeAngleRange < defaultAngleRangeHalf - epsilonAngle;
   const shapeIsAngleRangeHalf =
     shapeAngleRange >= defaultAngleRangeHalf - epsilonAngle &&
     shapeAngleRange <= defaultAngleRangeHalf + epsilonAngle;
-  const shapeIsAngleRangeZero = shapeAngleRange <= epsilonAngle;
   const shapeHasAngle =
-    shapeIsAngleRegular ||
-    shapeIsAngleFlipped ||
-    shapeIsAngleRangeHalf ||
-    shapeIsAngleRangeZero;
+    shapeIsAngleRegular || shapeIsAngleFlipped || shapeIsAngleRangeHalf;
   const shapeIsMinAngleDiscontinuity = CesiumMath.equalsEpsilon(
     shapeMinAngle,
     defaultMinAngle,
@@ -357,23 +348,16 @@ VoxelCylinderShape.prototype.update = function (
   const renderAngleRange =
     renderMaxAngle - renderMinAngle + renderIsAngleReversed * defaultAngleRange;
   const renderIsAngleRegular =
-    renderAngleRange > defaultAngleRangeHalf + epsilonAngle &&
+    renderAngleRange >= defaultAngleRangeHalf - epsilonAngle &&
     renderAngleRange < defaultAngleRange - epsilonAngle;
   const renderIsAngleFlipped =
     renderAngleRange > epsilonAngle &&
     renderAngleRange < defaultAngleRangeHalf - epsilonAngle;
-  const renderIsAngleRangeHalf =
-    renderAngleRange >= defaultAngleRangeHalf - epsilonAngle &&
-    renderAngleRange <= defaultAngleRangeHalf + epsilonAngle;
   const renderIsAngleRangeZero = renderAngleRange <= epsilonAngle;
   const renderHasAngle =
-    renderIsAngleRegular ||
-    renderIsAngleFlipped ||
-    renderIsAngleRangeHalf ||
-    renderIsAngleRangeZero;
+    renderIsAngleRegular || renderIsAngleFlipped || renderIsAngleRangeZero;
 
-  const shaderUniforms = this.shaderUniforms;
-  const shaderDefines = this.shaderDefines;
+  const { shaderUniforms, shaderDefines } = this;
 
   // To keep things simple, clear the defines every time
   for (const key in shaderDefines) {
@@ -408,12 +392,6 @@ VoxelCylinderShape.prototype.update = function (
   if (renderMinHeight === renderMaxHeight) {
     shaderDefines["CYLINDER_HAS_RENDER_BOUNDS_HEIGHT_FLAT"] = true;
   }
-  if (shapeMinHeight === shapeMaxHeight) {
-    shaderDefines["CYLINDER_HAS_SHAPE_BOUNDS_HEIGHT_FLAT"] = true;
-  }
-  if (shapeMinRadius === shapeMaxRadius) {
-    shaderDefines["CYLINDER_HAS_SHAPE_BOUNDS_RADIUS_FLAT"] = true;
-  }
   if (!shapeIsDefaultRadius) {
     shaderDefines["CYLINDER_HAS_SHAPE_BOUNDS_RADIUS"] = true;
 
@@ -423,8 +401,13 @@ VoxelCylinderShape.prototype.update = function (
     // scale = 1.0 / (maxRadius - minRadius)
     // offset = -minRadius / (maxRadius - minRadius)
     // offset = minRadius / (minRadius - maxRadius)
-    const scale = 1.0 / (shapeMaxRadius - shapeMinRadius);
-    const offset = shapeMinRadius / (shapeMinRadius - shapeMaxRadius);
+    const radiusRange = shapeMaxRadius - shapeMinRadius;
+    let scale = 0.0;
+    let offset = 1.0;
+    if (radiusRange !== 0.0) {
+      scale = 1.0 / radiusRange;
+      offset = -shapeMinRadius / radiusRange;
+    }
     shaderUniforms.cylinderUvToShapeUvRadius = Cartesian2.fromElements(
       scale,
       offset,
@@ -446,8 +429,13 @@ VoxelCylinderShape.prototype.update = function (
     // offset = -2.0 * (minHeight * 0.5 + 0.5) / (maxHeight - minHeight)
     // offset = -(minHeight + 1.0) / (maxHeight - minHeight)
     // offset = (minHeight + 1.0) / (minHeight - maxHeight)
-    const scale = 2.0 / (shapeMaxHeight - shapeMinHeight);
-    const offset = (shapeMinHeight + 1.0) / (shapeMinHeight - shapeMaxHeight);
+    const heightRange = shapeMaxHeight - shapeMinHeight;
+    let scale = 0.0;
+    let offset = 1.0;
+    if (heightRange !== 0.0) {
+      scale = 2.0 / heightRange;
+      offset = -(shapeMinHeight + 1.0) / heightRange;
+    }
     shaderUniforms.cylinderUvToShapeUvHeight = Cartesian2.fromElements(
       scale,
       offset,
@@ -505,9 +493,6 @@ VoxelCylinderShape.prototype.update = function (
     } else if (renderIsAngleFlipped) {
       shaderDefines["CYLINDER_HAS_RENDER_BOUNDS_ANGLE_RANGE_OVER_HALF"] = true;
       intersectionCount += 2;
-    } else if (renderIsAngleRangeHalf) {
-      shaderDefines["CYLINDER_HAS_RENDER_BOUNDS_ANGLE_RANGE_EQUAL_HALF"] = true;
-      intersectionCount += 1;
     } else if (renderIsAngleRangeZero) {
       shaderDefines["CYLINDER_HAS_RENDER_BOUNDS_ANGLE_RANGE_EQUAL_ZERO"] = true;
       intersectionCount += 2;
@@ -522,9 +507,6 @@ VoxelCylinderShape.prototype.update = function (
 
   if (shapeHasAngle) {
     shaderDefines["CYLINDER_HAS_SHAPE_BOUNDS_ANGLE"] = true;
-    if (shapeIsAngleRangeZero) {
-      shaderDefines["CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_RANGE_EQUAL_ZERO"] = true;
-    }
     if (shapeIsMinAngleDiscontinuity) {
       shaderDefines["CYLINDER_HAS_SHAPE_BOUNDS_ANGLE_MIN_DISCONTINUITY"] = true;
     }
@@ -553,13 +535,21 @@ VoxelCylinderShape.prototype.update = function (
     // offset = -uvMinAngle / (uvMaxAngle - uvMinAngle)
     // offset = -((minAngle - pi) / (2.0 * pi)) / (((maxAngle - pi) / (2.0 * pi)) - ((minAngle - pi) / (2.0 * pi)))
     // offset = -(minAngle - pi) / (maxAngle - minAngle)
-    const scale = defaultAngleRange / shapeAngleRange;
-    const offset = -(shapeMinAngle - defaultMinAngle) / shapeAngleRange;
-    shaderUniforms.cylinderUvToShapeUvAngle = Cartesian2.fromElements(
-      scale,
-      offset,
-      shaderUniforms.cylinderUvToShapeUvAngle
-    );
+    if (shapeAngleRange <= epsilonAngle) {
+      shaderUniforms.cylinderUvToShapeUvAngle = Cartesian2.fromElements(
+        0.0,
+        1.0,
+        shaderUniforms.cylinderUvToShapeUvAngle
+      );
+    } else {
+      const scale = defaultAngleRange / shapeAngleRange;
+      const offset = -(shapeMinAngle - defaultMinAngle) / shapeAngleRange;
+      shaderUniforms.cylinderUvToShapeUvAngle = Cartesian2.fromElements(
+        scale,
+        offset,
+        shaderUniforms.cylinderUvToShapeUvAngle
+      );
+    }
   }
 
   this.shaderMaximumIntersectionsLength = intersectionCount;
@@ -645,6 +635,87 @@ VoxelCylinderShape.prototype.computeOrientedBoundingBoxForTile = function (
   );
 };
 
+const sampleSizeScratch = new Cartesian3();
+const scratchTileMinBounds = new Cartesian3();
+const scratchTileMaxBounds = new Cartesian3();
+
+/**
+ * Computes an oriented bounding box for a specified sample within a specified tile.
+ * The update function must be called before calling this function.
+ *
+ * @param {SpatialNode} spatialNode The spatial node containing the sample
+ * @param {Cartesian3} tileDimensions The size of the tile in number of samples, before padding
+ * @param {Cartesian3} tileUv The sample coordinate within the tile
+ * @param {OrientedBoundingBox} result The oriented bounding box that will be set to enclose the specified sample
+ * @returns {OrientedBoundingBox} The oriented bounding box.
+ */
+VoxelCylinderShape.prototype.computeOrientedBoundingBoxForSample = function (
+  spatialNode,
+  tileDimensions,
+  tileUv,
+  result
+) {
+  //>>includeStart('debug', pragmas.debug);
+  Check.typeOf.object("spatialNode", spatialNode);
+  Check.typeOf.object("tileDimensions", tileDimensions);
+  Check.typeOf.object("tileUv", tileUv);
+  Check.typeOf.object("result", result);
+  //>>includeEnd('debug');
+
+  const tileSizeAtLevel = 1.0 / Math.pow(2.0, spatialNode.level);
+  const sampleSize = Cartesian3.divideComponents(
+    Cartesian3.ONE,
+    tileDimensions,
+    sampleSizeScratch
+  );
+  const sampleSizeAtLevel = Cartesian3.multiplyByScalar(
+    sampleSize,
+    tileSizeAtLevel,
+    sampleSizeScratch
+  );
+
+  const minLerp = Cartesian3.multiplyByScalar(
+    Cartesian3.fromElements(
+      spatialNode.x + tileUv.x,
+      spatialNode.y + tileUv.y,
+      spatialNode.z + tileUv.z,
+      scratchTileMinBounds
+    ),
+    tileSizeAtLevel,
+    scratchTileMinBounds
+  );
+  const maxLerp = Cartesian3.add(
+    minLerp,
+    sampleSizeAtLevel,
+    scratchTileMaxBounds
+  );
+
+  const minimumRadius = this._minimumRadius;
+  const maximumRadius = this._maximumRadius;
+  const minimumHeight = this._minimumHeight;
+  const maximumHeight = this._maximumHeight;
+  const minimumAngle = this._minimumAngle;
+  const maximumAngle = this._maximumAngle;
+
+  const radiusStart = CesiumMath.lerp(minimumRadius, maximumRadius, minLerp.x);
+  const radiusEnd = CesiumMath.lerp(minimumRadius, maximumRadius, maxLerp.x);
+  const heightStart = CesiumMath.lerp(minimumHeight, maximumHeight, minLerp.y);
+  const heightEnd = CesiumMath.lerp(minimumHeight, maximumHeight, maxLerp.y);
+  const angleStart = CesiumMath.lerp(minimumAngle, maximumAngle, minLerp.z);
+  const angleEnd = CesiumMath.lerp(minimumAngle, maximumAngle, maxLerp.z);
+
+  return getCylinderChunkObb(
+    radiusStart,
+    radiusEnd,
+    heightStart,
+    heightEnd,
+    angleStart,
+    angleEnd,
+    this.shapeTransform,
+    result
+  );
+};
+
 const scratchOrientedBoundingBox = new OrientedBoundingBox();
 const scratchVoxelScale = new Cartesian3();
 const scratchRootScale = new Cartesian3();