@cesium/engine 7.0.0 → 9.0.0

package/Source/Scene/VoxelPrimitive.js

@@ -22,6 +22,9 @@ import PolylineCollection from "./PolylineCollection.js";
 import VoxelShapeType from "./VoxelShapeType.js";
 import VoxelTraversal from "./VoxelTraversal.js";
 import CustomShader from "./Model/CustomShader.js";
+import Cartographic from "../Core/Cartographic.js";
+import Ellipsoid from "../Core/Ellipsoid.js";
+import VerticalExaggeration from "../Core/VerticalExaggeration.js";
 
 /**
  * A primitive that renders voxel data from a {@link VoxelProvider}.
@@ -231,6 +234,14 @@ function VoxelPrimitive(options) {
     defaultValue(options.modelMatrix, Matrix4.IDENTITY)
   );
 
+  /**
+   * Model matrix with vertical exaggeration applied. Only used for BOX shape type.
+   *
+   * @type {Matrix4}
+   * @private
+   */
+  this._exaggeratedModelMatrix = Matrix4.clone(this._modelMatrix);
+
   /**
    * The primitive's model matrix multiplied by the provider's model matrix.
    * This member is not known until the provider is ready.
@@ -320,18 +331,12 @@ function VoxelPrimitive(options) {
    */
   this._transformNormalLocalToWorld = new Matrix3();
 
-  /**
-   * @type {number}
-   * @private
-   */
-  this._stepSizeUv = 1.0;
-
   // Rendering
   /**
    * @type {boolean}
    * @private
    */
-  this._jitter = true;
+  this._jitter = false;
 
   /**
    * @type {boolean}
@@ -469,12 +474,25 @@ function initialize(primitive, provider) {
   primitive.minClippingBounds = VoxelShapeType.getMinBounds(shapeType);
   primitive.maxClippingBounds = VoxelShapeType.getMaxBounds(shapeType);
 
+  // Initialize the exaggerated versions of bounds and model matrix
+  primitive._exaggeratedMinBounds = Cartesian3.clone(
+    primitive._minBounds,
+    primitive._exaggeratedMinBounds
+  );
+  primitive._exaggeratedMaxBounds = Cartesian3.clone(
+    primitive._maxBounds,
+    primitive._exaggeratedMaxBounds
+  );
+  primitive._exaggeratedModelMatrix = Matrix4.clone(
+    primitive._modelMatrix,
+    primitive._exaggeratedModelMatrix
+  );
+
   checkTransformAndBounds(primitive, provider);
 
   // Create the shape object, and update it so it is valid for VoxelTraversal
   const ShapeConstructor = VoxelShapeType.getShapeConstructor(shapeType);
   primitive._shape = new ShapeConstructor();
-  updateVerticalExaggeration(primitive);
   primitive._shapeVisible = updateShapeAndTransforms(
     primitive,
     primitive._shape,
@@ -531,7 +549,7 @@ Object.defineProperties(VoxelPrimitive.prototype, {
    */
   orientedBoundingBox: {
     get: function () {
-      return this.shape.orientedBoundingBox;
+      return this._shape.orientedBoundingBox;
     },
   },
 
@@ -1132,21 +1150,28 @@ VoxelPrimitive.prototype.update = function (frameState) {
     cameraPositionWorld,
     uniforms.cameraPositionUv
   );
-  uniforms.stepSize = this._stepSizeUv * this._stepSizeMultiplier;
+  uniforms.stepSize = this._stepSizeMultiplier;
 
   // Render the primitive
   const command = frameState.passes.pick
     ? this._drawCommandPick
+    : frameState.passes.pickVoxel
+    ? this._drawCommandPickVoxel
     : this._drawCommand;
   command.boundingVolume = shape.boundingSphere;
   frameState.commandList.push(command);
 };
 
+const scratchExaggerationScale = new Cartesian3();
+const scratchExaggerationCenter = new Cartesian3();
+const scratchCartographicCenter = new Cartographic();
+const scratchExaggerationTranslation = new Cartesian3();
+
 /**
  * Update the exaggerated bounds of a primitive to account for vertical exaggeration
  * Currently only applies to Ellipsoid shape type
  * @param {VoxelPrimitive} primitive
- * @param {FrameState} [frameState]
+ * @param {FrameState} frameState
  * @private
  */
 function updateVerticalExaggeration(primitive, frameState) {
@@ -1158,16 +1183,87 @@ function updateVerticalExaggeration(primitive, frameState) {
     primitive._maxBounds,
     primitive._exaggeratedMaxBounds
   );
-  if (defined(frameState) && primitive.shape === VoxelShapeType.ELLIPSOID) {
+
+  if (primitive.shape === VoxelShapeType.ELLIPSOID) {
+    // Apply the exaggeration by stretching the height bounds
     const relativeHeight = frameState.verticalExaggerationRelativeHeight;
     const exaggeration = frameState.verticalExaggeration;
     primitive._exaggeratedMinBounds.z =
       (primitive._minBounds.z - relativeHeight) * exaggeration + relativeHeight;
     primitive._exaggeratedMaxBounds.z =
       (primitive._maxBounds.z - relativeHeight) * exaggeration + relativeHeight;
+  } else if (primitive.shape === VoxelShapeType.BOX) {
+    // Apply the exaggeration via the model matrix
+    const exaggerationScale = Cartesian3.fromElements(
+      1.0,
+      1.0,
+      frameState.verticalExaggeration,
+      scratchExaggerationScale
+    );
+    primitive._exaggeratedModelMatrix = Matrix4.multiplyByScale(
+      primitive._modelMatrix,
+      exaggerationScale,
+      primitive._exaggeratedModelMatrix
+    );
+    primitive._exaggeratedModelMatrix = Matrix4.multiplyByTranslation(
+      primitive._exaggeratedModelMatrix,
+      computeBoxExaggerationTranslation(primitive, frameState),
+      primitive._exaggeratedModelMatrix
+    );
   }
 }
 
+function computeBoxExaggerationTranslation(primitive, frameState) {
+  // Compute translation based on box center, relative height, and exaggeration
+  const {
+    shapeTransform = Matrix4.IDENTITY,
+    globalTransform = Matrix4.IDENTITY,
+  } = primitive._provider;
+
+  // Find the Cartesian position of the center of the OBB
+  const initialCenter = Matrix4.getTranslation(
+    shapeTransform,
+    scratchExaggerationCenter
+  );
+  const intermediateCenter = Matrix4.multiplyByPoint(
+    primitive._modelMatrix,
+    initialCenter,
+    scratchExaggerationCenter
+  );
+  const transformedCenter = Matrix4.multiplyByPoint(
+    globalTransform,
+    intermediateCenter,
+    scratchExaggerationCenter
+  );
+
+  // Find the cartographic height
+  const ellipsoid = Ellipsoid.WGS84;
+  const centerCartographic = ellipsoid.cartesianToCartographic(
+    transformedCenter,
+    scratchCartographicCenter
+  );
+
+  let centerHeight = 0.0;
+  if (defined(centerCartographic)) {
+    centerHeight = centerCartographic.height;
+  }
+
+  // Find the shift that will put the center in the right position relative
+  // to relativeHeight, after it is scaled by verticalExaggeration
+  const exaggeratedHeight = VerticalExaggeration.getHeight(
+    centerHeight,
+    frameState.verticalExaggeration,
+    frameState.verticalExaggerationRelativeHeight
+  );
+
+  return Cartesian3.fromElements(
+    0.0,
+    0.0,
+    (exaggeratedHeight - centerHeight) / frameState.verticalExaggeration,
+    scratchExaggerationTranslation
+  );
+}
+
 /**
  * Initialize primitive properties that are derived from the voxel provider
  * @param {VoxelPrimitive} primitive
@@ -1252,7 +1348,7 @@ function checkTransformAndBounds(primitive, provider) {
   // Compound model matrix = global transform * model matrix * shape transform
   Matrix4.multiplyTransformation(
     globalTransform,
-    primitive._modelMatrix,
+    primitive._exaggeratedModelMatrix,
     primitive._compoundModelMatrix
   );
   Matrix4.multiplyTransformation(
@@ -1343,8 +1439,6 @@ function updateShapeAndTransforms(primitive, shape, provider) {
   );
 
   // Set member variables when the shape is dirty
-  const dimensions = provider.dimensions;
-  primitive._stepSizeUv = shape.computeApproximateStepSize(dimensions);
   primitive._transformPositionWorldToUv = Matrix4.multiplyTransformation(
     transformPositionLocalToUv,
     transformPositionWorldToLocal,

package/Source/Scene/VoxelRenderResources.js

@@ -3,11 +3,13 @@ import combine from "../Core/combine.js";
 import defined from "../Core/defined.js";
 import ShaderBuilder from "../Renderer/ShaderBuilder.js";
 import ShaderDestination from "../Renderer/ShaderDestination.js";
+import VoxelUtils from "../Shaders/Voxels/VoxelUtils.js";
 import VoxelFS from "../Shaders/Voxels/VoxelFS.js";
 import VoxelVS from "../Shaders/Voxels/VoxelVS.js";
 import IntersectionUtils from "../Shaders/Voxels/IntersectionUtils.js";
 import IntersectDepth from "../Shaders/Voxels/IntersectDepth.js";
 import IntersectClippingPlanes from "../Shaders/Voxels/IntersectClippingPlanes.js";
+import IntersectLongitude from "../Shaders/Voxels/IntersectLongitude.js";
 import IntersectBox from "../Shaders/Voxels/IntersectBox.js";
 import IntersectCylinder from "../Shaders/Voxels/IntersectCylinder.js";
 import IntersectEllipsoid from "../Shaders/Voxels/IntersectEllipsoid.js";
@@ -88,6 +90,7 @@ function VoxelRenderResources(primitive) {
     customShader.fragmentShaderText,
     "#line 0",
     Octree,
+    VoxelUtils,
     IntersectionUtils,
     Megatexture,
   ]);
@@ -123,7 +126,6 @@ function VoxelRenderResources(primitive) {
 
   const shapeType = primitive._provider.shape;
   if (shapeType === "BOX") {
-    shaderBuilder.addDefine("SHAPE_BOX", undefined, ShaderDestination.FRAGMENT);
     shaderBuilder.addFragmentLines([
       convertUvToBox,
       IntersectBox,
@@ -131,15 +133,22 @@ function VoxelRenderResources(primitive) {
     ]);
   } else if (shapeType === "CYLINDER") {
     shaderBuilder.addFragmentLines([
+      convertUvToCylinder,
+      IntersectLongitude,
       IntersectCylinder,
       Intersection,
-      convertUvToCylinder,
     ]);
   } else if (shapeType === "ELLIPSOID") {
+    shaderBuilder.addDefine(
+      "SHAPE_ELLIPSOID",
+      undefined,
+      ShaderDestination.FRAGMENT
+    );
     shaderBuilder.addFragmentLines([
+      convertUvToEllipsoid,
+      IntersectLongitude,
       IntersectEllipsoid,
       Intersection,
-      convertUvToEllipsoid,
     ]);
   }
 

package/Source/Scene/VoxelShape.js

@@ -118,13 +118,16 @@ VoxelShape.prototype.computeOrientedBoundingBoxForTile =
   DeveloperError.throwInstantiationError;
 
 /**
- * Computes an approximate step size for raymarching the root tile of a voxel grid.
+ * Computes an oriented bounding box for a specified sample within a specified tile.
  * The update function must be called before calling this function.
  *
- * @param {Cartesian3} voxelDimensions The voxel grid dimensions for a tile.
- * @returns {number} The step size.
+ * @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.
  */
-VoxelShape.prototype.computeApproximateStepSize =
+VoxelShape.prototype.computeOrientedBoundingBoxForSample =
   DeveloperError.throwInstantiationError;
 
 /**

package/Source/Scene/VoxelTraversal.js

@@ -49,16 +49,14 @@ function VoxelTraversal(
    */
   this._primitive = primitive;
 
-  const length = types.length;
-
   /**
    * @type {Megatexture[]}
    * @readonly
    */
-  this.megatextures = new Array(length);
+  this.megatextures = new Array(types.length);
 
   // TODO make sure to split the maximumTextureMemoryByteLength across all the megatextures
-  for (let i = 0; i < length; i++) {
+  for (let i = 0; i < types.length; i++) {
     const type = types[i];
     const componentCount = MetadataType.getComponentCount(type);
     const componentType = componentTypes[i];
@@ -218,6 +216,18 @@ function VoxelTraversal(
   this.leafNodeTexelSizeUv = new Cartesian2();
 }
 
+/**
+ * Finds a keyframe node in the traversal
+ *
+ * @param {number} megatextureIndex
+ * @returns {KeyframeNode}
+ */
+VoxelTraversal.prototype.findKeyframeNode = function (megatextureIndex) {
+  return this._keyframeNodesInMegatexture.find(function (keyframeNode) {
+    return keyframeNode.megatextureIndex === megatextureIndex;
+  });
+};
+
 function binaryTreeWeightingRecursive(arr, start, end, depth) {
   if (start > end) {
     return;
@@ -382,10 +392,7 @@ VoxelTraversal.prototype.destroy = function () {
  * @private
  */
 function recomputeBoundingVolumesRecursive(that, node) {
-  const primitive = that._primitive;
-  const shape = primitive._shape;
-  const dimensions = primitive._provider.dimensions;
-  node.computeBoundingVolumes(shape, dimensions);
+  node.computeBoundingVolumes(that._primitive._shape);
   if (defined(node.children)) {
     for (let i = 0; i < 8; i++) {
       const child = node.children[i];
@@ -410,12 +417,11 @@ function requestData(that, keyframeNode) {
     return;
   }
 
-  const primitive = that._primitive;
-  const provider = primitive._provider;
+  const provider = that._primitive._provider;
 
   function postRequestSuccess(result) {
     that._simultaneousRequestCount--;
-    const length = primitive._provider.types.length;
+    const length = provider.types.length;
 
     if (!defined(result)) {
       keyframeNode.state = KeyframeNode.LoadState.UNAVAILABLE;
@@ -434,7 +440,7 @@ function requestData(that, keyframeNode) {
         const data = result[i];
         const expectedLength = tileVoxelCount * channelCount;
         if (data.length === expectedLength) {
-          keyframeNode.metadatas[i] = data;
+          keyframeNode.metadata[i] = data;
           // State is received only when all metadata requests have been received
           keyframeNode.state = KeyframeNode.LoadState.RECEIVED;
         } else {
@@ -492,42 +498,22 @@ function loadAndUnload(that, frameState) {
   const frameNumber = that._frameNumber;
   const primitive = that._primitive;
   const shape = primitive._shape;
-  const { dimensions } = primitive;
   const targetScreenSpaceError = primitive.screenSpaceError;
   const priorityQueue = that._priorityQueue;
-  const keyframeLocation = that._keyframeLocation;
   const keyframeCount = that._keyframeCount;
-  const rootNode = that.rootNode;
+
+  const previousKeyframe = CesiumMath.clamp(
+    Math.floor(that._keyframeLocation),
+    0,
+    keyframeCount - 2
+  );
+  const nextKeyframe = previousKeyframe + 1;
 
   const { camera, context, pixelRatio } = frameState;
   const { positionWC, frustum } = camera;
   const screenHeight = context.drawingBufferHeight / pixelRatio;
   const screenSpaceErrorMultiplier = screenHeight / frustum.sseDenominator;
 
-  function keyframePriority(previousKeyframe, keyframe, nextKeyframe) {
-    const keyframeDifference = Math.min(
-      Math.abs(keyframe - previousKeyframe),
-      Math.abs(keyframe - nextKeyframe)
-    );
-    const maxKeyframeDifference = Math.max(
-      previousKeyframe,
-      keyframeCount - nextKeyframe - 1,
-      1
-    );
-    const keyframeFactor = Math.pow(
-      1.0 - keyframeDifference / maxKeyframeDifference,
-      4.0
-    );
-    const binaryTreeFactor = Math.exp(
-      -that._binaryTreeKeyframeWeighting[keyframe]
-    );
-    return CesiumMath.lerp(
-      binaryTreeFactor,
-      keyframeFactor,
-      0.15 + 0.85 * keyframeFactor
-    );
-  }
-
   /**
    * @ignore
    * @param {SpatialNode} spatialNode
@@ -545,13 +531,6 @@ function loadAndUnload(that, frameState) {
     }
     spatialNode.visitedFrameNumber = frameNumber;
 
-    const previousKeyframe = CesiumMath.clamp(
-      Math.floor(keyframeLocation),
-      0,
-      keyframeCount - 2
-    );
-    const nextKeyframe = previousKeyframe + 1;
-
     // Create keyframe nodes at the playhead.
     // If they already exist, nothing will be created.
     if (keyframeCount === 1) {
@@ -561,16 +540,21 @@ function loadAndUnload(that, frameState) {
         spatialNode.createKeyframeNode(k);
       }
     }
-    const ssePriority = mapInfiniteRangeToZeroOne(spatialNode.screenSpaceError);
+    const { screenSpaceError, keyframeNodes } = spatialNode;
+    const ssePriority = mapInfiniteRangeToZeroOne(screenSpaceError);
 
     let hasLoadedKeyframe = false;
-    const keyframeNodes = spatialNode.keyframeNodes;
     for (let i = 0; i < keyframeNodes.length; i++) {
       const keyframeNode = keyframeNodes[i];
 
       keyframeNode.priority =
         10.0 * ssePriority +
-        keyframePriority(previousKeyframe, keyframeNode.keyframe, nextKeyframe);
+        keyframePriority(
+          previousKeyframe,
+          keyframeNode.keyframe,
+          nextKeyframe,
+          that
+        );
 
       if (
         keyframeNode.state !== KeyframeNode.LoadState.UNAVAILABLE &&
@@ -584,16 +568,14 @@ function loadAndUnload(that, frameState) {
       }
     }
 
-    const meetsScreenSpaceError =
-      spatialNode.screenSpaceError < targetScreenSpaceError;
-    if (meetsScreenSpaceError || !hasLoadedKeyframe) {
+    if (screenSpaceError < targetScreenSpaceError || !hasLoadedKeyframe) {
       // Free up memory
       spatialNode.children = undefined;
       return;
     }
 
     if (!defined(spatialNode.children)) {
-      spatialNode.constructChildNodes(shape, dimensions);
+      spatialNode.constructChildNodes(shape);
     }
     for (let childIndex = 0; childIndex < 8; childIndex++) {
       const child = spatialNode.children[childIndex];
@@ -601,9 +583,11 @@ function loadAndUnload(that, frameState) {
     }
   }
 
+  // Add all the nodes to the queue, to sort them by priority.
   priorityQueue.reset();
-  addToQueueRecursive(rootNode, CullingVolume.MASK_INDETERMINATE);
+  addToQueueRecursive(that.rootNode, CullingVolume.MASK_INDETERMINATE);
 
+  // Move the nodes from the queue to array of high priority nodes.
   const highPriorityKeyframeNodes = that._highPriorityKeyframeNodes;
   let highPriorityKeyframeNodeCount = 0;
   let highPriorityKeyframeNode;
@@ -616,6 +600,8 @@ function loadAndUnload(that, frameState) {
     highPriorityKeyframeNodeCount++;
   }
 
+  // Sort the list of keyframe nodes in the megatexture by priority, so
+  // we can remove the lowest priority nodes if we need space.
   const keyframeNodesInMegatexture = that._keyframeNodesInMegatexture;
   // TODO: some of the megatexture state should be stored once, not duplicate for each megatexture
   const megatexture = that.megatextures[0];
@@ -628,6 +614,8 @@ function loadAndUnload(that, frameState) {
     return b.highPriorityFrameNumber - a.highPriorityFrameNumber;
   });
 
+  // Add the high priority nodes to the megatexture,
+  // removing existing lower-priority nodes if necessary.
   let destroyedCount = 0;
   let addedCount = 0;
 
@@ -675,6 +663,40 @@ function loadAndUnload(that, frameState) {
   }
 }
 
+/**
+ * Compute a priority for a keyframe node.
+ *
+ * @private
+ * @param {number} previousKeyframe
+ * @param {number} keyframe
+ * @param {number} nextKeyframe
+ * @param {VoxelTraversal} traversal
+ * @returns {number} The computed priority
+ */
+function keyframePriority(previousKeyframe, keyframe, nextKeyframe, traversal) {
+  const keyframeDifference = Math.min(
+    Math.abs(keyframe - previousKeyframe),
+    Math.abs(keyframe - nextKeyframe)
+  );
+  const maxKeyframeDifference = Math.max(
+    previousKeyframe,
+    traversal._keyframeCount - nextKeyframe - 1,
+    1
+  );
+  const keyframeFactor = Math.pow(
+    1.0 - keyframeDifference / maxKeyframeDifference,
+    4.0
+  );
+  const binaryTreeFactor = Math.exp(
+    -traversal._binaryTreeKeyframeWeighting[keyframe]
+  );
+  return CesiumMath.lerp(
+    binaryTreeFactor,
+    keyframeFactor,
+    0.15 + 0.85 * keyframeFactor
+  );
+}
+
 /**
  * @function
  *

package/Source/Scene/buildVoxelDrawCommands.js

@@ -58,8 +58,17 @@ function buildVoxelDrawCommands(primitive, context) {
   // Compile shaders
   const shaderBuilderPick = shaderBuilder.clone();
   shaderBuilderPick.addDefine("PICKING", undefined, ShaderDestination.FRAGMENT);
+  const shaderBuilderPickVoxel = shaderBuilder.clone();
+  shaderBuilderPickVoxel.addDefine(
+    "PICKING_VOXEL",
+    undefined,
+    ShaderDestination.FRAGMENT
+  );
   const shaderProgram = shaderBuilder.buildShaderProgram(context);
   const shaderProgramPick = shaderBuilderPick.buildShaderProgram(context);
+  const shaderProgramPickVoxel = shaderBuilderPickVoxel.buildShaderProgram(
+    context
+  );
   const renderState = RenderState.fromCache({
     cull: {
       enabled: true,
@@ -98,6 +107,14 @@ function buildVoxelDrawCommands(primitive, context) {
   drawCommandPick.shaderProgram = shaderProgramPick;
   drawCommandPick.pickOnly = true;
 
+  // Create the pick voxels draw command
+  const drawCommandPickVoxel = DrawCommand.shallowClone(
+    drawCommand,
+    new DrawCommand()
+  );
+  drawCommandPickVoxel.shaderProgram = shaderProgramPickVoxel;
+  drawCommandPickVoxel.pickOnly = true;
+
   // Delete the old shader programs
   if (defined(primitive._drawCommand)) {
     const command = primitive._drawCommand;
@@ -109,9 +126,15 @@ function buildVoxelDrawCommands(primitive, context) {
     command.shaderProgram =
       command.shaderProgram && command.shaderProgram.destroy();
   }
+  if (defined(primitive._drawCommandPickVoxel)) {
+    const command = primitive._drawCommandPickVoxel;
+    command.shaderProgram =
+      command.shaderProgram && command.shaderProgram.destroy();
+  }
 
   primitive._drawCommand = drawCommand;
   primitive._drawCommandPick = drawCommandPick;
+  primitive._drawCommandPickVoxel = drawCommandPickVoxel;
 }
 
 export default buildVoxelDrawCommands;

package/Source/Scene/createGooglePhotorealistic3DTileset.js

@@ -46,6 +46,7 @@ async function createGooglePhotorealistic3DTileset(key, options) {
     options.maximumCacheOverflowBytes,
     1024 * 1024 * 1024
   );
+  options.enableCollision = defaultValue(options.enableCollision, true);
 
   key = defaultValue(key, GoogleMaps.defaultApiKey);
   if (!defined(key)) {

package/Source/Scene/processVoxelProperties.js

@@ -153,6 +153,9 @@ function processVoxelProperties(renderResources, primitive) {
   shaderBuilder.addStructField(voxelStructId, "vec3", "viewDirWorld");
   shaderBuilder.addStructField(voxelStructId, "vec3", "surfaceNormal");
   shaderBuilder.addStructField(voxelStructId, "float", "travelDistance");
+  shaderBuilder.addStructField(voxelStructId, "int", "stepCount");
+  shaderBuilder.addStructField(voxelStructId, "int", "tileIndex");
+  shaderBuilder.addStructField(voxelStructId, "int", "sampleIndex");
 
   // FragmentInput struct
   const fragmentInputStructId = "FragmentInput";