@cesium/engine 16.0.0 → 18.0.0

package/Source/Scene/Model/ModelRenderResources.js

@@ -101,6 +101,19 @@ function ModelRenderResources(model) {
    * @private
    */
   this.hasSkipLevelOfDetail = false;
+
+  /**
+   * The NodeRenderResources for the nodes of the scene graph.
+   *
+   * Note that elements of this array may be <code>undefined</code> when
+   * there was no runtime node for a certain node.
+   *
+   * @type {NodeRenderResources[]}
+   * @default []
+   *
+   * @private
+   */
+  this.nodeRenderResources = [];
 }
 
 export default ModelRenderResources;

package/Source/Scene/Model/ModelRuntimePrimitive.js

@@ -12,6 +12,7 @@ import CustomShaderPipelineStage from "./CustomShaderPipelineStage.js";
 import DequantizationPipelineStage from "./DequantizationPipelineStage.js";
 import FeatureIdPipelineStage from "./FeatureIdPipelineStage.js";
 import GeometryPipelineStage from "./GeometryPipelineStage.js";
+import ImageryPipelineStage from "./ImageryPipelineStage.js";
 import LightingPipelineStage from "./LightingPipelineStage.js";
 import MaterialPipelineStage from "./MaterialPipelineStage.js";
 import MetadataPickingPipelineStage from "./MetadataPickingPipelineStage.js";
@@ -27,6 +28,7 @@ import SelectedFeatureIdPipelineStage from "./SelectedFeatureIdPipelineStage.js"
 import SkinningPipelineStage from "./SkinningPipelineStage.js";
 import VerticalExaggerationPipelineStage from "./VerticalExaggerationPipelineStage.js";
 import WireframePipelineStage from "./WireframePipelineStage.js";
+import oneTimeWarning from "../../Core/oneTimeWarning.js";
 
 /**
  * In memory representation of a single primitive, that is, a primitive
@@ -206,6 +208,12 @@ ModelRuntimePrimitive.prototype.configurePipeline = function (frameState) {
   const hasMorphTargets =
     defined(primitive.morphTargets) && primitive.morphTargets.length > 0;
   const hasSkinning = defined(node.skin);
+
+  // Check whether the model is part of a `Model3DTileContent` that
+  // belongs to a tileset that has imagery layers. If this is the
+  // case, then the `ImageryPipelineStage` will be required.
+  const hasImageryLayers = defined(model.imageryLayers);
+
   const hasCustomShader = defined(customShader);
   const hasCustomFragmentShader =
     hasCustomShader && defined(customShader.fragmentShaderText);
@@ -270,6 +278,17 @@ ModelRuntimePrimitive.prototype.configurePipeline = function (frameState) {
     pipelineStages.push(DequantizationPipelineStage);
   }
 
+  if (hasImageryLayers) {
+    if (hasOutlines) {
+      oneTimeWarning(
+        "outlines-and-draping",
+        "Primitive outlines disable imagery draping",
+      );
+    } else {
+      pipelineStages.push(ImageryPipelineStage);
+    }
+  }
+
   if (materialsEnabled) {
     pipelineStages.push(MaterialPipelineStage);
   }

package/Source/Scene/Model/ModelSceneGraph.js

@@ -445,6 +445,7 @@ const scratchModelPositionMin = new Cartesian3();
 const scratchModelPositionMax = new Cartesian3();
 const scratchPrimitivePositionMin = new Cartesian3();
 const scratchPrimitivePositionMax = new Cartesian3();
+
 /**
  * Generates the {@link ModelDrawCommand} for each primitive in the model.
  * If the model is used for classification, a {@link ClassificationModelDrawCommand}
@@ -456,6 +457,30 @@ const scratchPrimitivePositionMax = new Cartesian3();
  * @private
  */
 ModelSceneGraph.prototype.buildDrawCommands = function (frameState) {
+  const modelRenderResources = this.buildRenderResources(frameState);
+  this.computeBoundingVolumes(modelRenderResources);
+  this.createDrawCommands(modelRenderResources, frameState);
+};
+
+/**
+ * Generates the {@link ModelRenderResources} for the model.
+ *
+ * This will traverse the model, nodes and primitives of the scene graph,
+ * and perform the following tasks:
+ *
+ * - configure the pipeline stages by calling `configurePipeline`,
+ *   `runtimeNode.configurePipeline`, and `runtimePrimitive.configurePipeline`
+ * - create the `ModelRenderResources`, `NodeRenderResources`, and
+ *   `PrimitiveRenderResources`
+ * - Process the render resources with the respective pipelines
+ *
+ * @param {FrameState} frameState The current frame state. This is needed to
+ * allocate GPU resources as needed.
+ * @returns {ModelRenderResources} The model render resources
+ *
+ * @private
+ */
+ModelSceneGraph.prototype.buildRenderResources = function (frameState) {
   const model = this._model;
   const modelRenderResources = new ModelRenderResources(model);
 
@@ -465,26 +490,12 @@ ModelSceneGraph.prototype.buildDrawCommands = function (frameState) {
   this.configurePipeline(frameState);
   const modelPipelineStages = this.modelPipelineStages;
 
-  let i, j, k;
-  for (i = 0; i < modelPipelineStages.length; i++) {
+  for (let i = 0; i < modelPipelineStages.length; i++) {
     const modelPipelineStage = modelPipelineStages[i];
     modelPipelineStage.process(modelRenderResources, model, frameState);
   }
 
-  const modelPositionMin = Cartesian3.fromElements(
-    Number.MAX_VALUE,
-    Number.MAX_VALUE,
-    Number.MAX_VALUE,
-    scratchModelPositionMin,
-  );
-  const modelPositionMax = Cartesian3.fromElements(
-    -Number.MAX_VALUE,
-    -Number.MAX_VALUE,
-    -Number.MAX_VALUE,
-    scratchModelPositionMax,
-  );
-
-  for (i = 0; i < this._runtimeNodes.length; i++) {
+  for (let i = 0; i < this._runtimeNodes.length; i++) {
     const runtimeNode = this._runtimeNodes[i];
 
     // If a node in the model was unreachable from the scene graph, there will
@@ -500,8 +511,9 @@ ModelSceneGraph.prototype.buildDrawCommands = function (frameState) {
       modelRenderResources,
       runtimeNode,
     );
+    modelRenderResources.nodeRenderResources[i] = nodeRenderResources;
 
-    for (j = 0; j < nodePipelineStages.length; j++) {
+    for (let j = 0; j < nodePipelineStages.length; j++) {
       const nodePipelineStage = nodePipelineStages[j];
 
       nodePipelineStage.process(
@@ -511,8 +523,7 @@ ModelSceneGraph.prototype.buildDrawCommands = function (frameState) {
       );
     }
 
-    const nodeTransform = runtimeNode.computedTransform;
-    for (j = 0; j < runtimeNode.runtimePrimitives.length; j++) {
+    for (let j = 0; j < runtimeNode.runtimePrimitives.length; j++) {
       const runtimePrimitive = runtimeNode.runtimePrimitives[j];
 
       runtimePrimitive.configurePipeline(frameState);
@@ -522,16 +533,76 @@ ModelSceneGraph.prototype.buildDrawCommands = function (frameState) {
         nodeRenderResources,
         runtimePrimitive,
       );
+      nodeRenderResources.primitiveRenderResources[j] =
+        primitiveRenderResources;
 
-      for (k = 0; k < primitivePipelineStages.length; k++) {
+      for (let k = 0; k < primitivePipelineStages.length; k++) {
         const primitivePipelineStage = primitivePipelineStages[k];
-
         primitivePipelineStage.process(
           primitiveRenderResources,
           runtimePrimitive.primitive,
           frameState,
         );
       }
+    }
+  }
+  return modelRenderResources;
+};
+
+/**
+ * Computes the bounding volumes for the scene graph and the model.
+ *
+ * This will traverse the model, nodes and primitives of the scene graph,
+ * and compute the bounding volumes. Specifically, it will compute
+ *
+ * - this._boundingSphere
+ * - model._boundingSphere
+ *
+ * With the latter being modified as of
+ *
+ * - model._initialRadius = model._boundingSphere.radius;
+ * - model._boundingSphere.radius *= model._clampedScale;
+ *
+ * NOTE: This contains some bugs. See https://github.com/CesiumGS/cesium/issues/12108
+ *
+ * @param {ModelRenderResources} modelRenderResources The model render resources
+ *
+ * @private
+ */
+ModelSceneGraph.prototype.computeBoundingVolumes = function (
+  modelRenderResources,
+) {
+  const model = this._model;
+
+  const modelPositionMin = Cartesian3.fromElements(
+    Number.MAX_VALUE,
+    Number.MAX_VALUE,
+    Number.MAX_VALUE,
+    scratchModelPositionMin,
+  );
+  const modelPositionMax = Cartesian3.fromElements(
+    -Number.MAX_VALUE,
+    -Number.MAX_VALUE,
+    -Number.MAX_VALUE,
+    scratchModelPositionMax,
+  );
+
+  for (let i = 0; i < this._runtimeNodes.length; i++) {
+    const runtimeNode = this._runtimeNodes[i];
+
+    // If a node in the model was unreachable from the scene graph, there will
+    // be no corresponding runtime node and therefore should be skipped.
+    if (!defined(runtimeNode)) {
+      continue;
+    }
+
+    const nodeRenderResources = modelRenderResources.nodeRenderResources[i];
+    const nodeTransform = runtimeNode.computedTransform;
+    for (let j = 0; j < runtimeNode.runtimePrimitives.length; j++) {
+      const runtimePrimitive = runtimeNode.runtimePrimitives[j];
+
+      const primitiveRenderResources =
+        nodeRenderResources.primitiveRenderResources[j];
 
       runtimePrimitive.boundingSphere = BoundingSphere.clone(
         primitiveRenderResources.boundingSphere,
@@ -559,12 +630,6 @@ ModelSceneGraph.prototype.buildDrawCommands = function (frameState) {
         primitivePositionMax,
         modelPositionMax,
       );
-
-      const drawCommand = ModelDrawCommands.buildModelDrawCommand(
-        primitiveRenderResources,
-        frameState,
-      );
-      runtimePrimitive.drawCommand = drawCommand;
     }
   }
 
@@ -596,6 +661,47 @@ ModelSceneGraph.prototype.buildDrawCommands = function (frameState) {
   model._boundingSphere.radius *= model._clampedScale;
 };
 
+/**
+ * Creates the draw commands for the primitives in the scene graph.
+ *
+ * This will traverse the model, nodes and primitives of the scene graph,
+ * and create the respective draw commands for the primitives, storing
+ * them as the `runtimePrimitive.drawCommand`, respectively.
+ *
+ * @param {ModelRenderResources} modelRenderResources The model render resources
+ *
+ * @private
+ */
+ModelSceneGraph.prototype.createDrawCommands = function (
+  modelRenderResources,
+  frameState,
+) {
+  for (let i = 0; i < this._runtimeNodes.length; i++) {
+    const runtimeNode = this._runtimeNodes[i];
+
+    // If a node in the model was unreachable from the scene graph, there will
+    // be no corresponding runtime node and therefore should be skipped.
+    if (!defined(runtimeNode)) {
+      continue;
+    }
+
+    const nodeRenderResources = modelRenderResources.nodeRenderResources[i];
+
+    for (let j = 0; j < runtimeNode.runtimePrimitives.length; j++) {
+      const runtimePrimitive = runtimeNode.runtimePrimitives[j];
+
+      const primitiveRenderResources =
+        nodeRenderResources.primitiveRenderResources[j];
+
+      const drawCommand = ModelDrawCommands.buildModelDrawCommand(
+        primitiveRenderResources,
+        frameState,
+      );
+      runtimePrimitive.drawCommand = drawCommand;
+    }
+  }
+};
+
 /**
  * Configure the model pipeline stages. If the pipeline needs to be re-run, call
  * this method again to ensure the correct sequence of pipeline stages are

package/Source/Scene/Model/NodeRenderResources.js

@@ -155,6 +155,16 @@ function NodeRenderResources(modelRenderResources, runtimeNode) {
    * @private
    */
   this.instanceCount = 0;
+
+  /**
+   * The PrimitiveRenderResources for the primitives of the node.
+   *
+   * @type {PrimitiveRenderResources[]}
+   * @default []
+   *
+   * @private
+   */
+  this.primitiveRenderResources = [];
 }
 
 export default NodeRenderResources;

package/Source/Scene/ModelComponents.js

@@ -620,6 +620,16 @@ function Primitive() {
    * @private
    */
   this.outlineCoordinates = undefined;
+
+  /**
+   * If the model is part of a Model3DTileContent of a Cesium3DTileset that
+   * has 'imageryLayers', then this will represent the information that is
+   * required for draping the imagery over this primitive.
+   *
+   * @type {ModelPrimitiveImagery|undefined}
+   * @private
+   */
+  this.modelPrimitiveImagery = undefined;
 }
 
 /**

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;