@cesium/engine 6.1.1 → 7.0.0

package/Source/Scene/Model/Model3DTileContent.js

@@ -3,6 +3,7 @@ import combine from "../../Core/combine.js";
 import defined from "../../Core/defined.js";
 import destroyObject from "../../Core/destroyObject.js";
 import DeveloperError from "../../Core/DeveloperError.js";
+import Ellipsoid from "../../Core/Ellipsoid.js";
 import Pass from "../../Renderer/Pass.js";
 import ModelAnimationLoop from "../ModelAnimationLoop.js";
 import Model from "./Model.js";
@@ -416,6 +417,35 @@ Model3DTileContent.fromGeoJson = async function (
   return content;
 };
 
+/**
+ * Find an intersection between a ray and the tile content surface that was rendered. The ray must be given in world coordinates.
+ *
+ * @param {Ray} ray The ray to test for intersection.
+ * @param {FrameState} frameState The frame state.
+ * @param {Cartesian3|undefined} [result] The intersection or <code>undefined</code> if none was found.
+ * @returns {Cartesian3|undefined} The intersection or <code>undefined</code> if none was found.
+ *
+ * @private
+ */
+Model3DTileContent.prototype.pick = function (ray, frameState, result) {
+  if (!defined(this._model) || !this._ready) {
+    return undefined;
+  }
+
+  const verticalExaggeration = frameState.verticalExaggeration;
+  const relativeHeight = frameState.verticalExaggerationRelativeHeight;
+
+  // All tilesets assume a WGS84 ellipsoid
+  return this._model.pick(
+    ray,
+    frameState,
+    verticalExaggeration,
+    relativeHeight,
+    Ellipsoid.WGS84,
+    result
+  );
+};
+
 function makeModelOptions(tileset, tile, content, additionalOptions) {
   const mainOptions = {
     cull: false, // The model is already culled by 3D Tiles
@@ -442,6 +472,7 @@ function makeModelOptions(tileset, tile, content, additionalOptions) {
     enableDebugWireframe: tileset._enableDebugWireframe,
     debugWireframe: tileset.debugWireframe,
     projectTo2D: tileset._projectTo2D,
+    enablePick: tileset._enablePick,
     enableShowOutline: tileset._enableShowOutline,
     showOutline: tileset.showOutline,
     outlineColor: tileset.outlineColor,

package/Source/Scene/Model/ModelAnimationChannel.js

@@ -215,7 +215,8 @@ function createSplines(times, points, interpolation, path, count) {
   return splines;
 }
 
-let scratchVariable;
+const scratchCartesian3 = new Cartesian3();
+const scratchQuaternion = new Quaternion();
 
 function initialize(runtimeChannel) {
   const channel = runtimeChannel._channel;
@@ -236,19 +237,6 @@ function initialize(runtimeChannel) {
 
   runtimeChannel._splines = splines;
   runtimeChannel._path = path;
-
-  switch (path) {
-    case AnimatedPropertyType.TRANSLATION:
-    case AnimatedPropertyType.SCALE:
-      scratchVariable = new Cartesian3();
-      break;
-    case AnimatedPropertyType.ROTATION:
-      scratchVariable = new Quaternion();
-      break;
-    case AnimatedPropertyType.WEIGHTS:
-      // This is unused when setting a node's morph weights.
-      break;
-  }
 }
 
 /**
@@ -286,7 +274,20 @@ ModelAnimationChannel.prototype.animate = function (time) {
       : spline.wrapTime(time);
 
     // This sets the translate, rotate, and scale properties.
-    runtimeNode[path] = spline.evaluate(localAnimationTime, scratchVariable);
+    if (
+      path === AnimatedPropertyType.TRANSLATION ||
+      path === AnimatedPropertyType.SCALE
+    ) {
+      runtimeNode[path] = spline.evaluate(
+        localAnimationTime,
+        scratchCartesian3
+      );
+    } else if (path === AnimatedPropertyType.ROTATION) {
+      runtimeNode[path] = spline.evaluate(
+        localAnimationTime,
+        scratchQuaternion
+      );
+    }
   }
 };
 

package/Source/Scene/Model/ModelRuntimePrimitive.js

@@ -24,6 +24,7 @@ import PrimitiveStatisticsPipelineStage from "./PrimitiveStatisticsPipelineStage
 import SceneMode2DPipelineStage from "./SceneMode2DPipelineStage.js";
 import SelectedFeatureIdPipelineStage from "./SelectedFeatureIdPipelineStage.js";
 import SkinningPipelineStage from "./SkinningPipelineStage.js";
+import VerticalExaggerationPipelineStage from "./VerticalExaggerationPipelineStage.js";
 import WireframePipelineStage from "./WireframePipelineStage.js";
 
 /**
@@ -198,6 +199,7 @@ ModelRuntimePrimitive.prototype.configurePipeline = function (frameState) {
   const mode = frameState.mode;
   const use2D =
     mode !== SceneMode.SCENE3D && !frameState.scene3DOnly && model._projectTo2D;
+  const exaggerateTerrain = frameState.verticalExaggeration !== 1.0;
 
   const hasMorphTargets =
     defined(primitive.morphTargets) && primitive.morphTargets.length > 0;
@@ -281,6 +283,10 @@ ModelRuntimePrimitive.prototype.configurePipeline = function (frameState) {
     pipelineStages.push(CPUStylingPipelineStage);
   }
 
+  if (exaggerateTerrain) {
+    pipelineStages.push(VerticalExaggerationPipelineStage);
+  }
+
   if (hasCustomShader) {
     pipelineStages.push(CustomShaderPipelineStage);
   }

package/Source/Scene/Model/ModelSceneGraph.js

@@ -9,6 +9,7 @@ import SceneMode from "../SceneMode.js";
 import SplitDirection from "../SplitDirection.js";
 import buildDrawCommand from "./buildDrawCommand.js";
 import TilesetPipelineStage from "./TilesetPipelineStage.js";
+import AtmospherePipelineStage from "./AtmospherePipelineStage.js";
 import ImageBasedLightingPipelineStage from "./ImageBasedLightingPipelineStage.js";
 import ModelArticulation from "./ModelArticulation.js";
 import ModelColorPipelineStage from "./ModelColorPipelineStage.js";
@@ -606,6 +607,7 @@ ModelSceneGraph.prototype.configurePipeline = function (frameState) {
   modelPipelineStages.length = 0;
 
   const model = this._model;
+  const fogRenderable = frameState.fog.enabled && frameState.fog.renderable;
 
   if (defined(model.color)) {
     modelPipelineStages.push(ModelColorPipelineStage);
@@ -638,6 +640,10 @@ ModelSceneGraph.prototype.configurePipeline = function (frameState) {
   if (ModelType.is3DTiles(model.type)) {
     modelPipelineStages.push(TilesetPipelineStage);
   }
+
+  if (fogRenderable) {
+    modelPipelineStages.push(AtmospherePipelineStage);
+  }
 };
 
 ModelSceneGraph.prototype.update = function (frameState, updateForAnimations) {

package/Source/Scene/Model/VerticalExaggerationPipelineStage.js

@@ -0,0 +1,60 @@
+import Cartesian2 from "../../Core/Cartesian2.js";
+import ShaderDestination from "../../Renderer/ShaderDestination.js";
+import VerticalExaggerationStageVS from "../../Shaders/Model/VerticalExaggerationStageVS.js";
+
+/**
+ * The custom shader pipeline stage takes GLSL callbacks from the
+ * {@link CustomShader} and inserts them into the overall shader code for the
+ * {@link Model}. The input to the callback is a struct with many
+ * properties that depend on the attributes of the primitive. This shader code
+ * is automatically generated by this stage.
+ *
+ * @namespace VerticalExaggerationPipelineStage
+ *
+ * @private
+ */
+const VerticalExaggerationPipelineStage = {
+  name: "VerticalExaggerationPipelineStage", // Helps with debugging
+};
+
+const scratchExaggerationUniform = new Cartesian2();
+
+/**
+ * Add vertical exaggeration to a shader
+ *
+ * @param {PrimitiveRenderResources} renderResources The render resources for the primitive
+ * @param {ModelComponents.Primitive} primitive The primitive to be rendered
+ * @param {FrameState} frameState The frame state.
+ * @private
+ */
+VerticalExaggerationPipelineStage.process = function (
+  renderResources,
+  primitive,
+  frameState
+) {
+  const { shaderBuilder, uniformMap } = renderResources;
+
+  shaderBuilder.addVertexLines(VerticalExaggerationStageVS);
+
+  shaderBuilder.addDefine(
+    "HAS_VERTICAL_EXAGGERATION",
+    undefined,
+    ShaderDestination.VERTEX
+  );
+
+  shaderBuilder.addUniform(
+    "vec2",
+    "u_verticalExaggerationAndRelativeHeight",
+    ShaderDestination.VERTEX
+  );
+
+  uniformMap.u_verticalExaggerationAndRelativeHeight = function () {
+    return Cartesian2.fromElements(
+      frameState.verticalExaggeration,
+      frameState.verticalExaggerationRelativeHeight,
+      scratchExaggerationUniform
+    );
+  };
+};
+
+export default VerticalExaggerationPipelineStage;

package/Source/Scene/Model/pickModel.js

@@ -0,0 +1,408 @@
+import AttributeCompression from "../../Core/AttributeCompression.js";
+import BoundingSphere from "../../Core/BoundingSphere.js";
+import Cartesian3 from "../../Core/Cartesian3.js";
+import Cartographic from "../../Core/Cartographic.js";
+import Check from "../../Core/Check.js";
+import ComponentDatatype from "../../Core/ComponentDatatype.js";
+import defaultValue from "../../Core/defaultValue.js";
+import defined from "../../Core/defined.js";
+import Ellipsoid from "../../Core/Ellipsoid.js";
+import IndexDatatype from "../../Core/IndexDatatype.js";
+import IntersectionTests from "../../Core/IntersectionTests.js";
+import Ray from "../../Core/Ray.js";
+import Matrix4 from "../../Core/Matrix4.js";
+import Transforms from "../../Core/Transforms.js";
+import VerticalExaggeration from "../../Core/VerticalExaggeration.js";
+import AttributeType from "../AttributeType.js";
+import SceneMode from "../SceneMode.js";
+import VertexAttributeSemantic from "../VertexAttributeSemantic.js";
+import ModelUtility from "./ModelUtility.js";
+
+const scratchV0 = new Cartesian3();
+const scratchV1 = new Cartesian3();
+const scratchV2 = new Cartesian3();
+const scratchNodeComputedTransform = new Matrix4();
+const scratchModelMatrix = new Matrix4();
+const scratchcomputedModelMatrix = new Matrix4();
+const scratchPickCartographic = new Cartographic();
+const scratchBoundingSphere = new BoundingSphere();
+
+/**
+ * Find an intersection between a ray and the model surface that was rendered. The ray must be given in world coordinates.
+ *
+ * @param {Model} model The model to pick.
+ * @param {Ray} ray The ray to test for intersection.
+ * @param {FrameState} frameState The frame state.
+ * @param {number} [verticalExaggeration=1.0] A scalar used to exaggerate the height of a position relative to the ellipsoid. If the value is 1.0 there will be no effect.
+ * @param {number} [relativeHeight=0.0] The ellipsoid height relative to which a position is exaggerated. If the value is 0.0 the position will be exaggerated relative to the ellipsoid surface.
+ * @param {Ellipsoid} [ellipsoid=Ellipsoid.WGS84] The ellipsoid to which the exaggerated position is relative.
+ * @param {Cartesian3|undefined} [result] The intersection or <code>undefined</code> if none was found.
+ * @returns {Cartesian3|undefined} The intersection or <code>undefined</code> if none was found.
+ *
+ * @private
+ */
+export default function pickModel(
+  model,
+  ray,
+  frameState,
+  verticalExaggeration,
+  relativeHeight,
+  ellipsoid,
+  result
+) {
+  //>>includeStart('debug', pragmas.debug);
+  Check.typeOf.object("model", model);
+  Check.typeOf.object("ray", ray);
+  Check.typeOf.object("frameState", frameState);
+  //>>includeEnd('debug');
+
+  if (!model._ready || frameState.mode === SceneMode.MORPHING) {
+    return;
+  }
+
+  let minT = Number.MAX_VALUE;
+  const sceneGraph = model.sceneGraph;
+
+  const nodes = sceneGraph._runtimeNodes;
+  for (let i = 0; i < nodes.length; i++) {
+    const runtimeNode = nodes[i];
+    const node = runtimeNode.node;
+
+    let nodeComputedTransform = Matrix4.clone(
+      runtimeNode.computedTransform,
+      scratchNodeComputedTransform
+    );
+    let modelMatrix = Matrix4.clone(
+      sceneGraph.computedModelMatrix,
+      scratchModelMatrix
+    );
+
+    const instances = node.instances;
+    if (defined(instances)) {
+      if (instances.transformInWorldSpace) {
+        // Replicate the multiplication order in LegacyInstancingStageVS.
+        modelMatrix = Matrix4.multiplyTransformation(
+          model.modelMatrix,
+          sceneGraph.components.transform,
+          modelMatrix
+        );
+
+        nodeComputedTransform = Matrix4.multiplyTransformation(
+          sceneGraph.axisCorrectionMatrix,
+          runtimeNode.computedTransform,
+          nodeComputedTransform
+        );
+      }
+    }
+
+    let computedModelMatrix = Matrix4.multiplyTransformation(
+      modelMatrix,
+      nodeComputedTransform,
+      scratchcomputedModelMatrix
+    );
+
+    if (frameState.mode !== SceneMode.SCENE3D) {
+      computedModelMatrix = Transforms.basisTo2D(
+        frameState.mapProjection,
+        computedModelMatrix,
+        computedModelMatrix
+      );
+    }
+
+    const transforms = [];
+    if (defined(instances)) {
+      const transformsCount = instances.attributes[0].count;
+      const instanceComponentDatatype =
+        instances.attributes[0].componentDatatype;
+
+      const transformElements = 12;
+      let transformsTypedArray = runtimeNode.transformsTypedArray;
+      if (!defined(transformsTypedArray)) {
+        const instanceTransformsBuffer = runtimeNode.instancingTransformsBuffer;
+        if (defined(instanceTransformsBuffer) && frameState.context.webgl2) {
+          transformsTypedArray = ComponentDatatype.createTypedArray(
+            instanceComponentDatatype,
+            transformsCount * transformElements
+          );
+          instanceTransformsBuffer.getBufferData(transformsTypedArray);
+        }
+      }
+
+      if (defined(transformsTypedArray)) {
+        for (let i = 0; i < transformsCount; i++) {
+          const index = i * transformElements;
+
+          const transform = new Matrix4(
+            transformsTypedArray[index],
+            transformsTypedArray[index + 1],
+            transformsTypedArray[index + 2],
+            transformsTypedArray[index + 3],
+            transformsTypedArray[index + 4],
+            transformsTypedArray[index + 5],
+            transformsTypedArray[index + 6],
+            transformsTypedArray[index + 7],
+            transformsTypedArray[index + 8],
+            transformsTypedArray[index + 9],
+            transformsTypedArray[index + 10],
+            transformsTypedArray[index + 11],
+            0,
+            0,
+            0,
+            1
+          );
+
+          if (instances.transformInWorldSpace) {
+            Matrix4.multiplyTransformation(
+              transform,
+              nodeComputedTransform,
+              transform
+            );
+            Matrix4.multiplyTransformation(modelMatrix, transform, transform);
+          } else {
+            Matrix4.multiplyTransformation(
+              transform,
+              computedModelMatrix,
+              transform
+            );
+          }
+          transforms.push(transform);
+        }
+      }
+    }
+
+    if (transforms.length === 0) {
+      transforms.push(computedModelMatrix);
+    }
+
+    const primitivesLength = runtimeNode.runtimePrimitives.length;
+    for (let j = 0; j < primitivesLength; j++) {
+      const runtimePrimitive = runtimeNode.runtimePrimitives[j];
+      const primitive = runtimePrimitive.primitive;
+
+      if (defined(runtimePrimitive.boundingSphere) && !defined(instances)) {
+        const boundingSphere = BoundingSphere.transform(
+          runtimePrimitive.boundingSphere,
+          computedModelMatrix,
+          scratchBoundingSphere
+        );
+        const boundsIntersection = IntersectionTests.raySphere(
+          ray,
+          boundingSphere
+        );
+        if (!defined(boundsIntersection)) {
+          continue;
+        }
+      }
+
+      const positionAttribute = ModelUtility.getAttributeBySemantic(
+        primitive,
+        VertexAttributeSemantic.POSITION
+      );
+      const vertexCount = positionAttribute.count;
+
+      if (!defined(primitive.indices)) {
+        // Point clouds
+        continue;
+      }
+
+      let indices = primitive.indices.typedArray;
+      if (!defined(indices)) {
+        const indicesBuffer = primitive.indices.buffer;
+        const indicesCount = primitive.indices.count;
+        const indexDatatype = primitive.indices.indexDatatype;
+        if (defined(indicesBuffer) && frameState.context.webgl2) {
+          if (indexDatatype === IndexDatatype.UNSIGNED_BYTE) {
+            indices = new Uint8Array(indicesCount);
+          } else if (indexDatatype === IndexDatatype.UNSIGNED_SHORT) {
+            indices = new Uint16Array(indicesCount);
+          } else if (indexDatatype === IndexDatatype.UNSIGNED_INT) {
+            indices = new Uint32Array(indicesCount);
+          }
+
+          indicesBuffer.getBufferData(indices);
+        }
+      }
+
+      let vertices = positionAttribute.typedArray;
+      let componentDatatype = positionAttribute.componentDatatype;
+      let attributeType = positionAttribute.type;
+
+      const quantization = positionAttribute.quantization;
+      if (defined(quantization)) {
+        componentDatatype = positionAttribute.quantization.componentDatatype;
+        attributeType = positionAttribute.quantization.type;
+      }
+
+      const numComponents = AttributeType.getNumberOfComponents(attributeType);
+      const elementCount = vertexCount * numComponents;
+
+      if (!defined(vertices)) {
+        const verticesBuffer = positionAttribute.buffer;
+
+        if (defined(verticesBuffer) && frameState.context.webgl2) {
+          vertices = ComponentDatatype.createTypedArray(
+            componentDatatype,
+            elementCount
+          );
+          verticesBuffer.getBufferData(
+            vertices,
+            positionAttribute.byteOffset,
+            0,
+            elementCount
+          );
+        }
+
+        if (quantization && positionAttribute.normalized) {
+          vertices = AttributeCompression.dequantize(
+            vertices,
+            componentDatatype,
+            attributeType,
+            vertexCount
+          );
+        }
+      }
+
+      if (!defined(indices) || !defined(vertices)) {
+        return;
+      }
+
+      ellipsoid = defaultValue(ellipsoid, Ellipsoid.WGS84);
+      verticalExaggeration = defaultValue(verticalExaggeration, 1.0);
+      relativeHeight = defaultValue(relativeHeight, 0.0);
+
+      const indicesLength = indices.length;
+      for (let i = 0; i < indicesLength; i += 3) {
+        const i0 = indices[i];
+        const i1 = indices[i + 1];
+        const i2 = indices[i + 2];
+
+        for (const instanceTransform of transforms) {
+          const v0 = getVertexPosition(
+            vertices,
+            i0,
+            numComponents,
+            quantization,
+            instanceTransform,
+            verticalExaggeration,
+            relativeHeight,
+            ellipsoid,
+            scratchV0
+          );
+          const v1 = getVertexPosition(
+            vertices,
+            i1,
+            numComponents,
+            quantization,
+            instanceTransform,
+            verticalExaggeration,
+            relativeHeight,
+            ellipsoid,
+            scratchV1
+          );
+          const v2 = getVertexPosition(
+            vertices,
+            i2,
+            numComponents,
+            quantization,
+            instanceTransform,
+            verticalExaggeration,
+            relativeHeight,
+            ellipsoid,
+            scratchV2
+          );
+
+          const t = IntersectionTests.rayTriangleParametric(
+            ray,
+            v0,
+            v1,
+            v2,
+            defaultValue(model.backFaceCulling, true)
+          );
+
+          if (defined(t)) {
+            if (t < minT && t >= 0.0) {
+              minT = t;
+            }
+          }
+        }
+      }
+    }
+  }
+
+  if (minT === Number.MAX_VALUE) {
+    return undefined;
+  }
+
+  result = Ray.getPoint(ray, minT, result);
+  if (frameState.mode !== SceneMode.SCENE3D) {
+    Cartesian3.fromElements(result.y, result.z, result.x, result);
+
+    const projection = frameState.mapProjection;
+    const ellipsoid = projection.ellipsoid;
+
+    const cartographic = projection.unproject(result, scratchPickCartographic);
+    ellipsoid.cartographicToCartesian(cartographic, result);
+  }
+
+  return result;
+}
+
+function getVertexPosition(
+  vertices,
+  index,
+  numComponents,
+  quantization,
+  instanceTransform,
+  verticalExaggeration,
+  relativeHeight,
+  ellipsoid,
+  result
+) {
+  const i = index * numComponents;
+  result.x = vertices[i];
+  result.y = vertices[i + 1];
+  result.z = vertices[i + 2];
+
+  if (defined(quantization)) {
+    if (quantization.octEncoded) {
+      result = AttributeCompression.octDecodeInRange(
+        result,
+        quantization.normalizationRange,
+        result
+      );
+
+      if (quantization.octEncodedZXY) {
+        const x = result.x;
+        result.x = result.z;
+        result.z = result.y;
+        result.y = x;
+      }
+    } else {
+      result = Cartesian3.multiplyComponents(
+        result,
+        quantization.quantizedVolumeStepSize,
+        result
+      );
+
+      result = Cartesian3.add(
+        result,
+        quantization.quantizedVolumeOffset,
+        result
+      );
+    }
+  }
+
+  result = Matrix4.multiplyByPoint(instanceTransform, result, result);
+
+  if (verticalExaggeration !== 1.0) {
+    VerticalExaggeration.getPosition(
+      result,
+      ellipsoid,
+      verticalExaggeration,
+      relativeHeight,
+      result
+    );
+  }
+
+  return result;
+}

package/Source/Scene/Multiple3DTileContent.js

@@ -1,3 +1,4 @@
+import Cartesian3 from "../Core/Cartesian3.js";
 import defined from "../Core/defined.js";
 import destroyObject from "../Core/destroyObject.js";
 import DeveloperError from "../Core/DeveloperError.js";
@@ -650,6 +651,47 @@ Multiple3DTileContent.prototype.update = function (tileset, frameState) {
   }
 };
 
+/**
+ * Find an intersection between a ray and the tile content surface that was rendered. The ray must be given in world coordinates.
+ *
+ * @param {Ray} ray The ray to test for intersection.
+ * @param {FrameState} frameState The frame state.
+ * @param {Cartesian3|undefined} [result] The intersection or <code>undefined</code> if none was found.
+ * @returns {Cartesian3|undefined} The intersection or <code>undefined</code> if none was found.
+ *
+ * @private
+ */
+Multiple3DTileContent.prototype.pick = function (ray, frameState, result) {
+  if (!this._ready) {
+    return undefined;
+  }
+
+  let intersection;
+  let minDistance = Number.POSITIVE_INFINITY;
+  const contents = this._contents;
+  const length = contents.length;
+
+  for (let i = 0; i < length; ++i) {
+    const candidate = contents[i].pick(ray, frameState, result);
+
+    if (!defined(candidate)) {
+      continue;
+    }
+
+    const distance = Cartesian3.distance(ray.origin, candidate);
+    if (distance < minDistance) {
+      intersection = candidate;
+      minDistance = distance;
+    }
+  }
+
+  if (!defined(intersection)) {
+    return undefined;
+  }
+
+  return result;
+};
+
 Multiple3DTileContent.prototype.isDestroyed = function () {
   return false;
 };

package/Source/Scene/QuadtreePrimitive.js

@@ -274,7 +274,7 @@ QuadtreePrimitive.prototype.forEachRenderedTile = function (tileFunction) {
  * is the cartesian position on the tile.
  *
  * @param {Cartographic} cartographic The cartographic position.
- * @param {Function} callback The function to be called when a new tile is loaded containing cartographic.
+ * @param {Function} callback The function to be called when a new tile is loaded containing the updated cartographic.
  * @returns {Function} The function to remove this callback from the quadtree.
  */
 QuadtreePrimitive.prototype.updateHeight = function (cartographic, callback) {