@cesium/engine 24.0.0 → 25.0.0

package/Source/Scene/Model/createVectorTileBuffersFromModelComponents.js

@@ -16,6 +16,7 @@ import VertexAttributeSemantic from "../VertexAttributeSemantic.js";
 import ModelReader from "./ModelReader.js";
 import ModelUtility from "./ModelUtility.js";
 import ModelComponents from "../ModelComponents.js";
+import Cesium3DTileVectorFeature from "../Cesium3DTileVectorFeature.js";
 
 /** @import { TypedArray } from "../../Core/globalTypes.js"; */
 /** @import BufferPrimitive from "../BufferPrimitive.js"; */
@@ -27,6 +28,7 @@ import ModelComponents from "../ModelComponents.js";
  * @typedef {object} VectorTileResult
  * @property {Array<BufferPrimitiveCollection<BufferPrimitive>>} collections
  * @property {Array<Matrix4>} collectionLocalMatrices
+ * @property {Map<number, Cesium3DTileVectorFeature>} features
  * @ignore
  */
 
@@ -48,7 +50,11 @@ function createVectorTileBuffersFromModelComponents(content, components) {
   const rootNodes = components.scene.nodes;
 
   /** @type {VectorTileResult} */
-  const result = { collections: [], collectionLocalMatrices: [] };
+  const result = {
+    collections: [],
+    collectionLocalMatrices: [],
+    features: new Map(),
+  };
 
   for (let i = 0; i < rootNodes.length; i++) {
     appendNodeToBuffers(content, rootNodes[i], Matrix4.IDENTITY, result);
@@ -113,12 +119,9 @@ function gatherPrimitiveStats(primitive) {
     ? ModelReader.readIndicesAsTypedArray(primitive.indices)
     : undefined;
 
-  // @ts-expect-error Requires https://github.com/CesiumGS/cesium/pull/13203.
   if (primitiveType === PrimitiveType.POINTS) {
     stats.pointPrimitiveCount += vector.count;
     stats.pointVertexCount += vector.count;
-
-    // @ts-expect-error Requires https://github.com/CesiumGS/cesium/pull/13203.
   } else if (primitiveType === PrimitiveType.LINE_STRIP) {
     //>>includeStart('debug', pragmas.debug);
     assert(defined(indices), "Vector LINE_STRIP primitive must be indexed.");
@@ -126,8 +129,6 @@ function gatherPrimitiveStats(primitive) {
 
     stats.polylinePrimitiveCount += vector.count;
     stats.polylineVertexCount += indices.length - (vector.count - 1);
-
-    // @ts-expect-error Requires https://github.com/CesiumGS/cesium/pull/13203.
   } else if (primitiveType === PrimitiveType.TRIANGLES) {
     //>>includeStart('debug', pragmas.debug);
     assert(defined(indices), "Vector TRIANGLES primitive must be indexed.");
@@ -154,9 +155,17 @@ function gatherPrimitiveStats(primitive) {
  * @param {VectorGltf3DTileContent} content
  * @param {Primitive} primitive
  * @param {BufferPrimitiveCollection<BufferPrimitive>} collection
+ * @param {number} collectionIndex
+ * @param {Map<number, Cesium3DTileVectorFeature>} features
  * @ignore
  */
-function appendPrimitiveToBuffers(content, primitive, collection) {
+function appendPrimitiveToBuffers(
+  content,
+  primitive,
+  collection,
+  collectionIndex,
+  features,
+) {
   const vector = primitive.vector;
   const positionAttribute = ModelUtility.getAttributeBySemantic(
     primitive,
@@ -174,10 +183,24 @@ function appendPrimitiveToBuffers(content, primitive, collection) {
     : undefined;
 
   const featureIdComponent = primitive.featureIds?.[0];
+
   /** @type {Attribute} */
   let featureIdAttribute;
+
   /** @type {TypedArray} */
   let featureIdArray;
+
+  /**
+   * @param {number} vertexOffset
+   * @returns {Cesium3DTileVectorFeature}
+   */
+  function getFeature(vertexOffset) {
+    const featureId = featureIdArray[vertexOffset];
+    if (featureId !== featureIdComponent.nullFeatureId) {
+      return features.get(featureId);
+    }
+  }
+
   if (featureIdComponent instanceof ModelComponents.FeatureIdAttribute) {
     featureIdAttribute = ModelUtility.getAttributeBySemantic(
       primitive,
@@ -187,6 +210,18 @@ function appendPrimitiveToBuffers(content, primitive, collection) {
     featureIdArray =
       featureIdAttribute.typedArray ??
       ModelReader.readAttributeAsTypedArray(featureIdAttribute);
+
+    for (let i = 0; i < featureIdArray.length; i++) {
+      const featureId = featureIdArray[i];
+      if (!features.has(featureId)) {
+        const feature = new Cesium3DTileVectorFeature(
+          content,
+          featureId,
+          featureIdComponent.propertyTableId,
+        );
+        features.set(featureId, feature);
+      }
+    }
   }
 
   if (collection instanceof BufferPointCollection) {
@@ -198,27 +233,31 @@ function appendPrimitiveToBuffers(content, primitive, collection) {
         vertexOffset * 3,
         scratchPosition,
       );
-      collection.add({ position: scratchPosition }, scratchPoint);
 
-      const featureId = Math.trunc(featureIdArray[vertexOffset]);
-      if (featureId !== featureIdComponent.nullFeatureId) {
-        scratchPoint.featureId = featureId;
-      }
+      const pickObject = getFeature(vertexOffset);
+      pickObject.addPrimitiveByCollection(collectionIndex, i);
+      const featureId = pickObject.featureId;
+
+      collection.add(
+        { position: scratchPosition, featureId, pickObject },
+        scratchPoint,
+      );
     }
   } else if (collection instanceof BufferPolylineCollection) {
     // @ts-expect-error TODO
     forEachLineStripSegment(indices, (indexOffset, indexCount) => {
+      const i = collection.primitiveCount;
       const vertexOffset = indices[indexOffset];
       const positions = collectionPositions.subarray(
         vertexOffset * 3,
         (vertexOffset + indexCount) * 3,
       );
-      collection.add({ positions }, scratchPolyline);
 
-      const featureId = Math.trunc(featureIdArray[vertexOffset]);
-      if (featureId !== featureIdComponent.nullFeatureId) {
-        scratchPolyline.featureId = featureId;
-      }
+      const pickObject = getFeature(vertexOffset);
+      pickObject.addPrimitiveByCollection(collectionIndex, i);
+      const featureId = pickObject.featureId;
+
+      collection.add({ positions, featureId, pickObject }, scratchPolyline);
     });
   } else if (collection instanceof BufferPolygonCollection) {
     const polygonAttributeOffsets = vector.polygonAttributeOffsets;
@@ -254,12 +293,14 @@ function appendPrimitiveToBuffers(content, primitive, collection) {
         triangles[t] -= polygonVertexStart;
       }
 
-      collection.add({ positions, triangles, holes }, scratchPolygon);
+      const pickObject = getFeature(polygonVertexStart);
+      pickObject.addPrimitiveByCollection(collectionIndex, i);
+      const featureId = pickObject.featureId;
 
-      const featureId = Math.trunc(featureIdArray[polygonVertexStart]);
-      if (featureId !== featureIdComponent.nullFeatureId) {
-        scratchPolygon.featureId = featureId;
-      }
+      collection.add(
+        { positions, triangles, holes, featureId, pickObject },
+        scratchPolygon,
+      );
     }
   }
 }
@@ -292,33 +333,37 @@ function appendNodeToBuffers(content, node, parentTransform, result) {
 
     const stats = gatherPrimitiveStats(primitive);
 
-    // @ts-expect-error Requires https://github.com/CesiumGS/cesium/pull/13203.
     if (primitiveType === PrimitiveType.POINTS) {
       collection = new BufferPointCollection({
         primitiveCountMax: stats.pointPrimitiveCount,
+        allowPicking: true,
       });
-
-      // @ts-expect-error Requires https://github.com/CesiumGS/cesium/pull/13203.
     } else if (primitiveType === PrimitiveType.LINE_STRIP) {
       collection = new BufferPolylineCollection({
         primitiveCountMax: stats.polylinePrimitiveCount,
         vertexCountMax: stats.polylineVertexCount,
+        allowPicking: true,
       });
-
-      // @ts-expect-error Requires https://github.com/CesiumGS/cesium/pull/13203.
     } else if (primitiveType === PrimitiveType.TRIANGLES) {
       collection = new BufferPolygonCollection({
         primitiveCountMax: stats.polygonPrimitiveCount,
         vertexCountMax: stats.polygonVertexCount,
         holeCountMax: stats.polygonHoleCount,
         triangleCountMax: stats.polygonTriangleCount,
+        allowPicking: true,
       });
     }
 
     result.collections.push(collection);
     result.collectionLocalMatrices.push(Matrix4.clone(nodeTransform));
 
-    appendPrimitiveToBuffers(content, primitive, collection);
+    appendPrimitiveToBuffers(
+      content,
+      primitive,
+      collection,
+      result.collections.length - 1,
+      result.features,
+    );
   }
 
   const children = node.children;

package/Source/Scene/Model/pickModel.js

@@ -1,31 +1,46 @@
-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 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 Ray from "../../Core/Ray.js";
 import VerticalExaggeration from "../../Core/VerticalExaggeration.js";
 import AttributeType from "../AttributeType.js";
 import SceneMode from "../SceneMode.js";
 import VertexAttributeSemantic from "../VertexAttributeSemantic.js";
+import ModelReader from "./ModelReader.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 scratchV0_t = new Cartesian3();
+const scratchV1_t = new Cartesian3();
+const scratchV2_t = new Cartesian3();
 const scratchPickCartographic = new Cartographic();
 const scratchBoundingSphere = new BoundingSphere();
 
+/**
+ * Reads a 3D position from a flat vertex array at the given element index.
+ *
+ * @param {TypedArray} vertices The flat array of vertex components.
+ * @param {number} index The vertex index (element index, not byte offset).
+ * @param {number} elementStride The number of components per vertex element.
+ * @param {Cartesian3} result The object into which to store the position.
+ * @returns {Cartesian3} The modified result parameter.
+ * @private
+ */
+function readPosition(vertices, index, elementStride, result) {
+  const i = index * elementStride;
+  result.x = vertices[i];
+  result.y = vertices[i + 1];
+  result.z = vertices[i + 2];
+  return result;
+}
+
 /**
  * Find an intersection between a ray and the model surface that was rendered. The ray must be given in world coordinates.
  *
@@ -60,125 +75,22 @@ export default function pickModel(
   }
 
   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)) {
+  ellipsoid = ellipsoid ?? Ellipsoid.default;
+  verticalExaggeration = verticalExaggeration ?? 1.0;
+  relativeHeight = relativeHeight ?? 0.0;
+
+  const mapProjection =
+    frameState.mode !== SceneMode.SCENE3D
+      ? frameState.mapProjection
+      : undefined;
+
+  ModelReader.forEachPrimitive(
+    model,
+    { mapProjection: mapProjection },
+    function (runtimePrimitive, primitive, instances, computedModelMatrix) {
+      // Bounding sphere early-out for non-instanced primitives
+      if (defined(runtimePrimitive.boundingSphere) && instances.length === 1) {
         const boundingSphere = BoundingSphere.transform(
           runtimePrimitive.boundingSphere,
           computedModelMatrix,
@@ -189,144 +101,88 @@ export default function pickModel(
           boundingSphere,
         );
         if (!defined(boundsIntersection)) {
-          continue;
+          return;
         }
       }
 
-      const positionAttribute = ModelUtility.getAttributeBySemantic(
-        primitive,
-        VertexAttributeSemantic.POSITION,
-      );
-      const byteOffset = positionAttribute.byteOffset;
-      const byteStride = positionAttribute.byteStride;
-      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;
+        return;
       }
 
-      const numComponents = AttributeType.getNumberOfComponents(attributeType);
-      const bytes = ComponentDatatype.getSizeInBytes(componentDatatype);
-      const isInterleaved =
-        !defined(vertices) &&
-        defined(byteStride) &&
-        byteStride !== numComponents * bytes;
-
-      let elementStride = numComponents;
-      let offset = 0;
-      if (isInterleaved) {
-        elementStride = byteStride / bytes;
-        offset = byteOffset / bytes;
+      let vertices;
+      let numPosComponents;
+      const positionAttribute = ModelUtility.getAttributeBySemantic(
+        primitive,
+        VertexAttributeSemantic.POSITION,
+      );
+      if (defined(positionAttribute)) {
+        numPosComponents = AttributeType.getNumberOfComponents(
+          positionAttribute.type,
+        );
+        vertices = ModelReader.readAttributeAsTypedArray(positionAttribute);
       }
-      const elementCount = vertexCount * elementStride;
-
-      if (!defined(vertices)) {
-        const verticesBuffer = positionAttribute.buffer;
-
-        if (defined(verticesBuffer) && frameState.context.webgl2) {
-          vertices = ComponentDatatype.createTypedArray(
-            componentDatatype,
-            elementCount,
-          );
-          verticesBuffer.getBufferData(
-            vertices,
-            isInterleaved ? 0 : byteOffset,
-            0,
-            elementCount,
-          );
-        }
 
-        if (quantization && positionAttribute.normalized) {
-          vertices = AttributeCompression.dequantize(
-            vertices,
-            componentDatatype,
-            attributeType,
-            vertexCount,
-          );
-        }
+      let indices;
+      if (defined(primitive.indices)) {
+        indices = ModelReader.readIndicesAsTypedArray(primitive.indices);
       }
 
       if (!defined(indices) || !defined(vertices)) {
         return;
       }
 
-      ellipsoid = ellipsoid ?? Ellipsoid.default;
-      verticalExaggeration = verticalExaggeration ?? 1.0;
-      relativeHeight = 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,
-            offset,
-            elementStride,
-            quantization,
-            instanceTransform,
-            verticalExaggeration,
-            relativeHeight,
-            ellipsoid,
+        readPosition(vertices, i0, numPosComponents, scratchV0);
+        readPosition(vertices, i1, numPosComponents, scratchV1);
+        readPosition(vertices, i2, numPosComponents, scratchV2);
+
+        for (const instance of instances) {
+          const v0 = Matrix4.multiplyByPoint(
+            instance.transform,
             scratchV0,
+            scratchV0_t,
           );
-          const v1 = getVertexPosition(
-            vertices,
-            i1,
-            offset,
-            elementStride,
-            quantization,
-            instanceTransform,
-            verticalExaggeration,
-            relativeHeight,
-            ellipsoid,
+          const v1 = Matrix4.multiplyByPoint(
+            instance.transform,
             scratchV1,
+            scratchV1_t,
           );
-          const v2 = getVertexPosition(
-            vertices,
-            i2,
-            offset,
-            elementStride,
-            quantization,
-            instanceTransform,
-            verticalExaggeration,
-            relativeHeight,
-            ellipsoid,
+          const v2 = Matrix4.multiplyByPoint(
+            instance.transform,
             scratchV2,
+            scratchV2_t,
           );
 
+          if (verticalExaggeration !== 1.0) {
+            VerticalExaggeration.getPosition(
+              v0,
+              ellipsoid,
+              verticalExaggeration,
+              relativeHeight,
+              v0,
+            );
+            VerticalExaggeration.getPosition(
+              v1,
+              ellipsoid,
+              verticalExaggeration,
+              relativeHeight,
+              v1,
+            );
+            VerticalExaggeration.getPosition(
+              v2,
+              ellipsoid,
+              verticalExaggeration,
+              relativeHeight,
+              v2,
+            );
+          }
+
           const t = IntersectionTests.rayTriangleParametric(
             ray,
             v0,
@@ -342,8 +198,8 @@ export default function pickModel(
           }
         }
       }
-    }
-  }
+    },
+  );
 
   if (minT === Number.MAX_VALUE) {
     return undefined;
@@ -362,64 +218,3 @@ export default function pickModel(
 
   return result;
 }
-
-function getVertexPosition(
-  vertices,
-  index,
-  offset,
-  numElements,
-  quantization,
-  instanceTransform,
-  verticalExaggeration,
-  relativeHeight,
-  ellipsoid,
-  result,
-) {
-  const i = offset + index * numElements;
-  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/ModelAnimationLoop.js

@@ -1,3 +1,5 @@
+// @ts-check
+
 /**
  * Determines if and how a glTF animation is looped.
  *
@@ -30,4 +32,7 @@ const ModelAnimationLoop = {
    */
   MIRRORED_REPEAT: 2,
 };
-export default Object.freeze(ModelAnimationLoop);
+
+Object.freeze(ModelAnimationLoop);
+
+export default ModelAnimationLoop;