@hztxi/cesium-engine 25.0.7 → 26.2.2

package/Source/Scene/VectorGltf3DTileContent.js

@@ -10,16 +10,17 @@ import BufferPolyline from "./BufferPolyline.js";
 import BufferPolylineCollection from "./BufferPolylineCollection.js";
 import BufferPolylineMaterial from "./BufferPolylineMaterial.js";
 import Cesium3DTileStyle from "./Cesium3DTileStyle.js";
-import Color from "../Core/Color.js";
 import Matrix4 from "../Core/Matrix4.js";
 import Model from "./Model/Model.js";
 import ModelUtility from "./Model/ModelUtility.js";
 import Pass from "../Renderer/Pass.js";
+import SceneMode from "./SceneMode.js";
 import createVectorTileBuffersFromModelComponents from "./Model/createVectorTileBuffersFromModelComponents.js";
 import defined from "../Core/defined.js";
 import destroyObject from "../Core/destroyObject.js";
 import DeveloperError from "../Core/DeveloperError.js";
-import Check from "../Core/Check.js";
+import { isHeightReferenceClamp } from "./HeightReference.js";
+import { getMvtLabelCandidatesByteLength } from "./MvtLabelCandidates.js";
 
 /** @import BufferPrimitive from "./BufferPrimitive.js"; */
 /** @import BufferPrimitiveCollection from "./BufferPrimitiveCollection.js"; */
@@ -29,11 +30,20 @@ import Check from "../Core/Check.js";
 /** @import Cesium3DTileBatchTable from "./Cesium3DTileBatchTable.js"; */
 /** @import Cesium3DTileVectorFeature from "./Cesium3DTileVectorFeature.js";*/
 /** @import Cesium3DTileset from "./Cesium3DTileset.js"; */
+/** @import Color from "../Core/Color.js"; */
 /** @import FrameState from "./FrameState.js"; */
 /** @import ImplicitMetadataView from "./ImplicitMetadataView.js"; */
 /** @import Ray from "../Core/Ray.js"; */
 /** @import Resource from "../Core/Resource.js"; */
 
+/**
+ * @typedef {object} VectorGltfModelStatistics
+ * @property {number} geometryByteLength
+ * @property {number} texturesByteLength
+ */
+
+/** @typedef {Model & {statistics: VectorGltfModelStatistics}} VectorGltfModel */
+
 /** @ignore */
 const point = new BufferPoint();
 /** @ignore */
@@ -71,7 +81,7 @@ class VectorGltf3DTileContent {
     /** @type {Resource} */
     this._resource = resource;
 
-    /** @type {Model} */
+    /** @type {VectorGltfModel} */
     this._model = undefined;
 
     /**
@@ -109,9 +119,16 @@ class VectorGltf3DTileContent {
 
     /** @type {boolean} */
     this._ready = false;
+    /** @type {SceneMode|undefined} */
+    this._collectionSceneMode = undefined;
 
     /** @type {Matrix4} */
     this._modelMatrix = Matrix4.clone(Matrix4.IDENTITY);
+
+    this._mvtLabelManager = undefined;
+    this._mvtLabelTile = undefined;
+    this._mvtLabelByteLength = 0;
+    this._renderVectorGeometry = true;
   }
 
   get featuresLength() {
@@ -139,20 +156,24 @@ class VectorGltf3DTileContent {
   }
 
   get geometryByteLength() {
-    return this._collections.reduce((totalByteLength, collection) => {
-      return totalByteLength + collection.byteLength;
-    }, 0);
+    // The source glTF model is retained after its components are baked into the
+    // vector collections, so its buffers must be reported for the tileset cache
+    // to size itself correctly.
+    return this._collections.reduce(
+      (totalByteLength, collection) => totalByteLength + collection.byteLength,
+      this._model?.statistics.geometryByteLength ?? 0,
+    );
   }
 
   get texturesByteLength() {
-    return 0;
+    return this._model?.statistics.texturesByteLength ?? 0;
   }
 
   get batchTableByteLength() {
     return this.batchTables.reduce(
       // @ts-expect-error Missing types.
       (acc, batchTable) => acc + batchTable.batchTableByteLength,
-      0,
+      this._mvtLabelByteLength,
     );
   }
 
@@ -210,21 +231,17 @@ class VectorGltf3DTileContent {
 
   /**
    * @param {number} featureId
-   * @param {number} featureTableId
+   * @param {number} [featureTableId]
    * @returns {Cesium3DTileVectorFeature}
    */
   getFeature(featureId, featureTableId) {
-    //>>includeStart('debug', pragmas.debug);
-    Check.typeOf.number("featureTableId", featureTableId);
-    //>>includeEnd('debug');
-
     return this._featuresByTableId.get(featureTableId)?.get(featureId);
   }
 
   /**
    * @param {number} featureId
    * @param {string} name
-   * @param {number} featureTableId
+   * @param {number} [featureTableId]
    * @returns {boolean}
    */
   hasProperty(featureId, name, featureTableId) {
@@ -237,8 +254,10 @@ class VectorGltf3DTileContent {
    * @param {Color} color
    */
   applyDebugSettings(enabled, color) {
-    color = enabled ? color : Color.WHITE;
-    this.applyStyle(new Cesium3DTileStyle({ color }));
+    const colorString = enabled
+      ? `color("${color.toCssHexString()}", 1.0)`
+      : 'color("white", 1.0)';
+    this.applyStyle(new Cesium3DTileStyle({ color: colorString }));
   }
 
   /**
@@ -258,11 +277,22 @@ class VectorGltf3DTileContent {
         collection.get(i, point);
         const feature = this.getFeature(point.featureId, featureTableId);
 
-        point.show = style.show?.evaluate(feature) ?? true;
-        style.color?.evaluate(feature, pointMaterial.color);
-        pointMaterial.size = style.pointSize?.evaluate(feature);
-        pointMaterial.outlineWidth = style.pointOutlineWidth?.evaluate(feature);
-        style.pointOutlineColor?.evaluate(feature, pointMaterial.outlineColor);
+        if (defined(style.show)) {
+          point.show = style.show.evaluate(feature);
+        }
+        if (defined(style.color)) {
+          style.color.evaluate(feature, pointMaterial.color);
+        }
+        if (defined(style.pointSize)) {
+          pointMaterial.size = style.pointSize.evaluate(feature);
+        }
+        if (defined(style.pointOutlineWidth)) {
+          pointMaterial.outlineWidth =
+            style.pointOutlineWidth.evaluate(feature);
+        }
+        if (defined(style.pointOutlineColor)) {
+          style.pointOutlineColor.evaluate(feature, pointMaterial.outlineColor);
+        }
 
         point.setMaterial(pointMaterial);
       }
@@ -274,9 +304,15 @@ class VectorGltf3DTileContent {
         collection.get(i, polyline);
         const feature = this.getFeature(polyline.featureId, featureTableId);
 
-        polyline.show = style.show?.evaluate(feature) ?? true;
-        style.color?.evaluate(feature, polylineMaterial.color);
-        polylineMaterial.width = style.lineWidth?.evaluate(feature) ?? 1;
+        if (defined(style.show)) {
+          polyline.show = style.show.evaluate(feature);
+        }
+        if (defined(style.color)) {
+          style.color.evaluate(feature, polylineMaterial.color);
+        }
+        if (defined(style.lineWidth)) {
+          polylineMaterial.width = style.lineWidth.evaluate(feature);
+        }
 
         polyline.setMaterial(polylineMaterial);
       }
@@ -284,12 +320,31 @@ class VectorGltf3DTileContent {
 
     for (const collection of this._collections.filter(isPolygonCollection)) {
       const featureTableId = this._collectionFeatureTableIds.get(collection);
+      collection._polygonOutlineEnabled =
+        defined(style.polygonOutlineColor) ||
+        defined(style.polygonOutlineWidth);
       for (let i = 0, il = collection.primitiveCount; i < il; i++) {
         collection.get(i, polygon);
         const feature = this.getFeature(polygon.featureId, featureTableId);
 
-        polygon.show = style.show?.evaluate(feature) ?? true;
-        style.color?.evaluate(feature, polygonMaterial.color);
+        if (defined(style.show)) {
+          polygon.show = style.show.evaluate(feature);
+        }
+        if (defined(style.color)) {
+          style.color.evaluate(feature, polygonMaterial.color);
+        }
+        if (defined(style.polygonOutlineColor)) {
+          style.polygonOutlineColor.evaluate(
+            feature,
+            polygonMaterial.outlineColor,
+          );
+        }
+        if (defined(style.polygonOutlineWidth)) {
+          const outlineWidth = style.polygonOutlineWidth.evaluate(feature);
+          polygonMaterial.outlineWidth = Number.isFinite(outlineWidth)
+            ? Math.max(0, outlineWidth)
+            : 0;
+        }
 
         polygon.setMaterial(polygonMaterial);
       }
@@ -301,6 +356,9 @@ class VectorGltf3DTileContent {
    * @param {FrameState} frameState
    */
   update(_tileset, frameState) {
+    const tileset = this._tileset;
+    const vectorProvider = tileset._scene?.vectorProvider;
+
     if (defined(this._model) && !this._ready) {
       const model = this._model;
       model.modelMatrix = this._tile.computedTransform;
@@ -308,24 +366,48 @@ class VectorGltf3DTileContent {
 
       // @ts-expect-error Requires Model conversion to ES6 class.
       if (model.ready) {
-        initializeVectorPrimitives(this);
+        initializeVectorPrimitives(this, frameState);
+        this._collectionSceneMode = frameState.mode;
         this._ready = true;
       }
     }
 
-    Matrix4.multiplyTransformation(
-      this._tile.computedTransform,
-      this._modelMatrix,
-      scratchTileModelMatrix,
-    );
+    if (
+      this._ready &&
+      frameState.mode !== this._collectionSceneMode &&
+      frameState.mode !== SceneMode.MORPHING
+    ) {
+      rebuildVectorPrimitives(this, frameState);
+    }
 
-    for (let i = 0; i < this._collections.length; i++) {
+    if (this._collectionSceneMode === SceneMode.SCENE3D) {
       Matrix4.multiplyTransformation(
+        this._tile.computedTransform,
+        this._modelMatrix,
         scratchTileModelMatrix,
-        this._collectionLocalMatrices[i],
-        this._collections[i].modelMatrix,
       );
-      this._collections[i].update(frameState);
+    } else {
+      Matrix4.clone(Matrix4.IDENTITY, scratchTileModelMatrix);
+    }
+
+    // Only bake collections selected to render this frame (avoids duplicates).
+    const isSelected = this._tile._selectedFrame === frameState.frameNumber;
+
+    if (this._renderVectorGeometry) {
+      for (let i = 0; i < this._collections.length; i++) {
+        const collection = this._collections[i];
+        Matrix4.multiplyTransformation(
+          scratchTileModelMatrix,
+          this._collectionLocalMatrices[i],
+          collection.modelMatrix,
+        );
+
+        if (!isHeightReferenceClamp(tileset._heightReference)) {
+          collection.update(frameState);
+        } else if (isSelected && defined(vectorProvider)) {
+          vectorProvider.markSelected(collection, frameState.frameNumber);
+        }
+      }
     }
   }
 
@@ -344,9 +426,18 @@ class VectorGltf3DTileContent {
   }
 
   destroy() {
+    const vectorProvider = this._tileset._scene?.vectorProvider;
+
     this._model?.destroy();
     this._model = undefined;
-    this._collections.forEach((collection) => collection.destroy());
+    for (const collection of this._collections) {
+      vectorProvider?.remove(collection);
+      collection.destroy();
+    }
+    this._mvtLabelManager?.removeTile(this._mvtLabelTile);
+    this._mvtLabelManager = undefined;
+    this._mvtLabelTile = undefined;
+    this._mvtLabelByteLength = 0;
     this._collections.length = 0;
     return destroyObject(this);
   }
@@ -355,16 +446,42 @@ class VectorGltf3DTileContent {
    * @param {Cesium3DTileset} tileset
    * @param {Cesium3DTile} tile
    * @param {Resource} resource
-   * @param {unknown} gltf
+   * @param {Uint8Array} glb GLB binary produced by buildVectorGltfFromMVT
+   * @param {*} [mvtLabelManager]
+   * @param {Array<*>} [mvtLabelCandidates]
+   * @param {{tileX:number,tileY:number,tileZ:number}} [tileCoordinates]
+   * @param {boolean} [renderVectorGeometry=true]
    * @returns {Promise<VectorGltf3DTileContent>}
    */
-  static async fromGltf(tileset, tile, resource, gltf) {
+  static async fromGltf(
+    tileset,
+    tile,
+    resource,
+    glb,
+    mvtLabelManager,
+    mvtLabelCandidates,
+    tileCoordinates,
+    renderVectorGeometry,
+  ) {
     const content = new VectorGltf3DTileContent(tileset, tile, resource);
-    const modelOptions = makeModelOptions(tileset, tile, content, gltf);
+    content._renderVectorGeometry = renderVectorGeometry ?? true;
+    const modelOptions = makeModelOptions(tileset, tile, content, glb);
     const model = await Model.fromGltfAsync(modelOptions);
     // @ts-expect-error Requires Model conversion to ES6 class.
     model.show = false;
-    content._model = model;
+    content._model = /** @type {VectorGltfModel} */ (model);
+    // Registered only once the load can no longer fail, so a rejected model
+    // cannot leave an orphaned tile in the label manager.
+    if (defined(mvtLabelManager) && defined(mvtLabelCandidates)) {
+      content._mvtLabelManager = mvtLabelManager;
+      content._mvtLabelTile = mvtLabelManager.addTile(
+        tile,
+        tileCoordinates,
+        mvtLabelCandidates,
+      );
+      content._mvtLabelByteLength =
+        getMvtLabelCandidatesByteLength(mvtLabelCandidates);
+    }
     return content;
   }
 }
@@ -373,13 +490,13 @@ class VectorGltf3DTileContent {
  * @param {Cesium3DTileset} tileset
  * @param {Cesium3DTile} tile
  * @param {VectorGltf3DTileContent} content
- * @param {unknown} gltf
+ * @param {Uint8Array} glb
  * @returns {*}
  * @ignore
  */
-function makeModelOptions(tileset, tile, content, gltf) {
+function makeModelOptions(tileset, tile, content, glb) {
   return {
-    gltf: gltf,
+    gltf: glb,
     basePath: content._resource,
     cull: false,
     releaseGltfJson: true,
@@ -402,9 +519,10 @@ function makeModelOptions(tileset, tile, content, gltf) {
 
 /**
  * @param {VectorGltf3DTileContent} content
+ * @param {FrameState} frameState
  * @ignore
  */
-function initializeVectorPrimitives(content) {
+function initializeVectorPrimitives(content, frameState) {
   // @ts-expect-error Requires Model conversion to ES6 class.
   const components = content._model.sceneGraph.components;
 
@@ -423,12 +541,34 @@ function initializeVectorPrimitives(content) {
   const result = createVectorTileBuffersFromModelComponents(
     content,
     components,
+    frameState,
   );
 
   content._collections = result.collections;
   content._collectionLocalMatrices = result.collectionLocalMatrices;
   content._collectionFeatureTableIds = result.collectionFeatureTableIds;
   content._featuresByTableId = result.featuresByTableId;
+  content._collectionSceneMode = frameState.mode;
+}
+
+/**
+ * @param {VectorGltf3DTileContent} content
+ * @param {FrameState} frameState
+ * @ignore
+ */
+function rebuildVectorPrimitives(content, frameState) {
+  const vectorProvider = content._tileset._scene?.vectorProvider;
+  for (const collection of content._collections) {
+    vectorProvider?.remove(collection);
+    collection.destroy();
+  }
+  content._collections.length = 0;
+  content._collectionLocalMatrices.length = 0;
+  content._collectionFeatureTableIds.clear();
+  content._featuresByTableId.clear();
+  initializeVectorPrimitives(content, frameState);
+  // @ts-expect-error Requires Cesium3DTileset conversion to ES6 class.
+  content.applyStyle(content._tileset.style);
 }
 
 export default VectorGltf3DTileContent;

package/Source/Scene/View.js

@@ -11,6 +11,7 @@ import Pass from "../Renderer/Pass.js";
 import PassState from "../Renderer/PassState.js";
 import Camera from "./Camera.js";
 import EdgeFramebuffer from "./EdgeFramebuffer.js";
+import PlanarFillIdFramebuffer from "./PlanarFillIdFramebuffer.js";
 import FrustumCommands from "./FrustumCommands.js";
 import GlobeDepth from "./GlobeDepth.js";
 import GlobeTranslucencyFramebuffer from "./GlobeTranslucencyFramebuffer.js";
@@ -62,9 +63,11 @@ function View(scene, camera, viewport) {
   this.viewport = viewport;
   this.passState = passState;
   this.pickFramebuffer = new PickFramebuffer(context);
+  this.snapFramebuffer = undefined;
   this.pickDepthFramebuffer = new PickDepthFramebuffer();
   this.sceneFramebuffer = new SceneFramebuffer();
   this.edgeFramebuffer = new EdgeFramebuffer();
+  this.planarFillIdFramebuffer = new PlanarFillIdFramebuffer();
   this.globeDepth = globeDepth;
   this.globeTranslucencyFramebuffer = new GlobeTranslucencyFramebuffer();
   this.oit = oit;
@@ -211,15 +214,11 @@ function updateFrustums(view, scene, near, far) {
       curNear = Math.max(near, Math.pow(farToNearRatio, m) * near);
       curFar = Math.min(far, farToNearRatio * curNear);
     }
-    let frustumCommands = frustumCommandsList[m];
-    if (!defined(frustumCommands)) {
-      frustumCommands = frustumCommandsList[m] = new FrustumCommands(
-        curNear,
-        curFar,
-      );
+    if (!defined(frustumCommandsList[m])) {
+      frustumCommandsList[m] = new FrustumCommands(curNear, curFar);
     } else {
-      frustumCommands.near = curNear;
-      frustumCommands.far = curFar;
+      frustumCommandsList[m].near = curNear;
+      frustumCommandsList[m].far = curFar;
     }
   }
 }
@@ -443,11 +442,14 @@ View.prototype.createPotentiallyVisibleSet = function (scene) {
 
 View.prototype.destroy = function () {
   this.pickFramebuffer = this.pickFramebuffer && this.pickFramebuffer.destroy();
+  this.snapFramebuffer = this.snapFramebuffer && this.snapFramebuffer.destroy();
   this.pickDepthFramebuffer =
     this.pickDepthFramebuffer && this.pickDepthFramebuffer.destroy();
   this.sceneFramebuffer =
     this.sceneFramebuffer && this.sceneFramebuffer.destroy();
   this.edgeFramebuffer = this.edgeFramebuffer && this.edgeFramebuffer.destroy();
+  this.planarFillIdFramebuffer =
+    this.planarFillIdFramebuffer && this.planarFillIdFramebuffer.destroy();
   this.globeDepth = this.globeDepth && this.globeDepth.destroy();
   this.oit = this.oit && this.oit.destroy();
   this.translucentTileClassification =