@cesium/engine 25.0.0 → 26.0.0

package/Source/Scene/Model/createVectorTileBuffersFromModelComponents.js

@@ -1,7 +1,6 @@
 // @ts-check
 
 import Cartesian3 from "../../Core/Cartesian3.js";
-import assert from "../../Core/assert.js";
 import defined from "../../Core/defined.js";
 import Matrix4 from "../../Core/Matrix4.js";
 import PrimitiveType from "../../Core/PrimitiveType.js";
@@ -18,17 +17,18 @@ import ModelUtility from "./ModelUtility.js";
 import ModelComponents from "../ModelComponents.js";
 import Cesium3DTileVectorFeature from "../Cesium3DTileVectorFeature.js";
 
-/** @import { TypedArray } from "../../Core/globalTypes.js"; */
+/** @import { TypedArray, TypedArrayConstructor } from "../../Core/globalTypes.js"; */
 /** @import BufferPrimitive from "../BufferPrimitive.js"; */
 /** @import BufferPrimitiveCollection from "../BufferPrimitiveCollection.js"; */
 /** @import VectorGltf3DTileContent from "../VectorGltf3DTileContent.js"; */
-/** @import {Attribute, Components, Node, Primitive} from "../ModelComponents.js"; */
+/** @import {Attribute, Components, Node, Polygon, Primitive, Vector} from "../ModelComponents.js"; */
 
 /**
  * @typedef {object} VectorTileResult
- * @property {Array<BufferPrimitiveCollection<BufferPrimitive>>} collections
- * @property {Array<Matrix4>} collectionLocalMatrices
- * @property {Map<number, Cesium3DTileVectorFeature>} features
+ * @property {Array<BufferPrimitiveCollection<BufferPrimitive>>} collections List of all vector primitive collections.
+ * @property {Array<Matrix4>} collectionLocalMatrices List of transform matrices for each collection; order matches 'collections'.
+ * @property {Map<BufferPrimitiveCollection<BufferPrimitive>, number>} collectionFeatureTableIds Maps vector primitive collection -> propertyTableId.
+ * @property {Map<number, Map<number, Cesium3DTileVectorFeature>>} featuresByTableId Maps propertyTableId -> featureId -> feature.
  * @ignore
  */
 
@@ -53,7 +53,8 @@ function createVectorTileBuffersFromModelComponents(content, components) {
   const result = {
     collections: [],
     collectionLocalMatrices: [],
-    features: new Map(),
+    collectionFeatureTableIds: new Map(),
+    featuresByTableId: new Map(),
   };
 
   for (let i = 0; i < rootNodes.length; i++) {
@@ -72,25 +73,6 @@ function getPrimitiveRestartIndex(indices) {
   return Math.pow(2, bits) - 1;
 }
 
-/**
- * @param {TypedArray} indices
- * @param {Function} callback
- * @ignore
- */
-function forEachLineStripSegment(indices, callback) {
-  const restart = getPrimitiveRestartIndex(indices);
-  let segmentStart = 0;
-  for (let i = 0; i <= indices.length; i++) {
-    if (i === indices.length || indices[i] === restart) {
-      const segmentCount = i - segmentStart;
-      if (segmentCount > 0) {
-        callback(segmentStart, segmentCount);
-      }
-      segmentStart = i + 1;
-    }
-  }
-}
-
 /**
  * @param {Primitive} primitive
  * @ignore
@@ -108,6 +90,7 @@ function gatherPrimitiveStats(primitive) {
   };
 
   const vector = primitive.vector;
+  const polygon = primitive.polygon;
   const primitiveType = primitive.primitiveType;
   const positionAttribute = ModelUtility.getAttributeBySemantic(
     primitive,
@@ -120,29 +103,33 @@ function gatherPrimitiveStats(primitive) {
     : undefined;
 
   if (primitiveType === PrimitiveType.POINTS) {
-    stats.pointPrimitiveCount += vector.count;
-    stats.pointVertexCount += vector.count;
+    stats.pointPrimitiveCount += positionCount;
+    stats.pointVertexCount += positionCount;
   } else if (primitiveType === PrimitiveType.LINE_STRIP) {
-    //>>includeStart('debug', pragmas.debug);
-    assert(defined(indices), "Vector LINE_STRIP primitive must be indexed.");
-    //>>includeEnd('debug');
-
-    stats.polylinePrimitiveCount += vector.count;
-    stats.polylineVertexCount += indices.length - (vector.count - 1);
-  } else if (primitiveType === PrimitiveType.TRIANGLES) {
-    //>>includeStart('debug', pragmas.debug);
-    assert(defined(indices), "Vector TRIANGLES primitive must be indexed.");
-    //>>includeEnd('debug');
-
-    stats.polygonPrimitiveCount += vector.count;
-    stats.polygonVertexCount += positionCount;
-    stats.polygonTriangleCount += indices.length / 3;
-
-    const polygonHoleCounts = vector.polygonHoleCounts;
-    if (polygonHoleCounts) {
-      for (let i = 0; i < polygonHoleCounts.length; i++) {
-        stats.polygonHoleCount += polygonHoleCounts[i];
+    const stripCount = vector ? vector.count : getPrimitiveCount(indices);
+    stats.polylinePrimitiveCount += stripCount;
+    stats.polylineVertexCount += indices.length - stripCount + 1;
+  } else if (
+    primitiveType === PrimitiveType.TRIANGLES ||
+    primitiveType === PrimitiveType.LINE_LOOP
+  ) {
+    if (vector) {
+      stats.polygonPrimitiveCount += vector.count;
+      stats.polygonVertexCount += positionCount;
+      stats.polygonTriangleCount += indices.length / 3;
+
+      const polygonHoleCounts = vector.polygonHoleCounts;
+      if (polygonHoleCounts) {
+        for (let i = 0; i < polygonHoleCounts.length; i++) {
+          stats.polygonHoleCount += polygonHoleCounts[i];
+        }
       }
+    } else {
+      const loopCount = getPrimitiveCount(polygon.loopIndices);
+      stats.polygonPrimitiveCount += polygon.count;
+      stats.polygonVertexCount += polygon.loopIndices.length - loopCount + 1;
+      stats.polygonTriangleCount += polygon.triangleIndices.length;
+      stats.polygonHoleCount += loopCount - polygon.count;
     }
   } else {
     throw new RuntimeError(`Unexpected primitive type: ${primitiveType}`);
@@ -151,6 +138,27 @@ function gatherPrimitiveStats(primitive) {
   return stats;
 }
 
+/**
+ * Returns the number of GL primitives, separated by primitive restart index
+ * values, defined in the given index list.
+ *
+ * @param {TypedArray} indices
+ * @ignore
+ */
+function getPrimitiveCount(indices) {
+  const restart = getPrimitiveRestartIndex(indices);
+
+  let count = 0;
+
+  for (let i = 0; i < indices.length; i++) {
+    if (indices[i] === restart && i + 1 < indices.length) {
+      count++;
+    }
+  }
+
+  return count + 1;
+}
+
 /**
  * @param {VectorGltf3DTileContent} content
  * @param {Primitive} primitive
@@ -166,7 +174,6 @@ function appendPrimitiveToBuffers(
   collectionIndex,
   features,
 ) {
-  const vector = primitive.vector;
   const positionAttribute = ModelUtility.getAttributeBySemantic(
     primitive,
     VertexAttributeSemantic.POSITION,
@@ -174,134 +181,370 @@ function appendPrimitiveToBuffers(
   /** @type {TypedArray} */
   const collectionPositions =
     positionAttribute.typedArray ??
-    ModelReader.readAttributeAsTypedArray(positionAttribute);
-  const vertexCount = collectionPositions.length / 3;
+    (collection.positionNormalized
+      ? ModelReader.readAttributeAsRawCompactTypedArray(positionAttribute)
+      : ModelReader.readAttributeAsTypedArray(positionAttribute));
 
   /** @type {TypedArray} */
   const indices = primitive.indices
     ? ModelReader.readIndicesAsTypedArray(primitive.indices)
     : undefined;
 
-  const featureIdComponent = primitive.featureIds?.[0];
+  const getFeature = createFeatureFactoryFn(content, primitive, features);
+
+  if (collection instanceof BufferPointCollection) {
+    appendBufferPoints(
+      collection,
+      collectionIndex,
+      collectionPositions,
+      indices,
+      getFeature,
+    );
+  } else if (collection instanceof BufferPolylineCollection) {
+    appendBufferPolylines(
+      collection,
+      collectionIndex,
+      collectionPositions,
+      indices,
+      getFeature,
+    );
+  } else if (collection instanceof BufferPolygonCollection) {
+    if (defined(primitive.vector)) {
+      appendBufferPolygonsDeprecated(
+        collection,
+        collectionIndex,
+        collectionPositions,
+        indices,
+        getFeature,
+        primitive.vector,
+      );
+    } else {
+      appendBufferPolygons(
+        collection,
+        collectionIndex,
+        collectionPositions,
+        getFeature,
+        primitive.polygon,
+      );
+    }
+  }
+}
 
-  /** @type {Attribute} */
-  let featureIdAttribute;
+/**
+ * @callback FeatureFactoryFn
+ * @param {number} vertexOffset
+ * @returns {Cesium3DTileVectorFeature|undefined}
+ * @ignore
+ */
+
+/**
+ * Returns a factory function that, given a vertex offset, returns the
+ * Cesium3DTileVectorFeature instance associated with the vertex.
+ *
+ * @param {VectorGltf3DTileContent} content
+ * @param {Primitive} primitive
+ * @param {Map<number, Cesium3DTileVectorFeature>} features
+ * @returns {FeatureFactoryFn}
+ * @ignore
+ */
+function createFeatureFactoryFn(content, primitive, features) {
+  // @ts-expect-error Missing types.
+  const label = content.tileset.featureIdLabel;
+  const featureIdComponent = ModelUtility.getFeatureIdsByLabel(
+    primitive.featureIds,
+    label,
+  );
+
+  if (!(featureIdComponent instanceof ModelComponents.FeatureIdAttribute)) {
+    return () => undefined;
+  }
+
+  const featureIdAttribute = ModelUtility.getAttributeBySemantic(
+    primitive,
+    VertexAttributeSemantic.FEATURE_ID,
+    featureIdComponent.setIndex,
+  );
 
   /** @type {TypedArray} */
-  let featureIdArray;
+  const 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);
+    }
+  }
 
-  /**
-   * @param {number} vertexOffset
-   * @returns {Cesium3DTileVectorFeature}
-   */
-  function getFeature(vertexOffset) {
+  /** @type {FeatureFactoryFn} */
+  return function getFeature(vertexOffset) {
     const featureId = featureIdArray[vertexOffset];
     if (featureId !== featureIdComponent.nullFeatureId) {
       return features.get(featureId);
     }
-  }
+  };
+}
 
-  if (featureIdComponent instanceof ModelComponents.FeatureIdAttribute) {
-    featureIdAttribute = ModelUtility.getAttributeBySemantic(
-      primitive,
-      VertexAttributeSemantic.FEATURE_ID,
-      featureIdComponent.setIndex,
+/**
+ * @param {BufferPointCollection} collection
+ * @param {number} collectionIndex
+ * @param {TypedArray} collectionPositions
+ * @param {TypedArray} indices
+ * @param {FeatureFactoryFn} getFeature
+ * @ignore
+ */
+function appendBufferPoints(
+  collection,
+  collectionIndex,
+  collectionPositions,
+  indices,
+  getFeature,
+) {
+  const vertexCount = collectionPositions.length / 3;
+
+  for (let i = 0, il = indices ? indices.length : vertexCount; i < il; i++) {
+    const vertexOffset = indices ? indices[i] : i;
+    Cartesian3.fromArray(
+      // @ts-expect-error https://github.com/CesiumGS/cesium/pull/13302
+      collectionPositions,
+      vertexOffset * 3,
+      scratchPosition,
     );
-    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);
-      }
+
+    const feature = getFeature(vertexOffset);
+    if (feature) {
+      feature.addPrimitiveByCollection(collectionIndex, i);
     }
+
+    collection.add(
+      {
+        position: scratchPosition,
+        pickObject: feature,
+        featureId: feature?.featureId,
+      },
+      scratchPoint,
+    );
   }
+}
 
-  if (collection instanceof BufferPointCollection) {
-    for (let i = 0, il = indices ? indices.length : vertexCount; i < il; i++) {
-      const vertexOffset = indices ? indices[i] : i;
-      Cartesian3.fromArray(
-        // @ts-expect-error TODO(tsd-jsdoc): See https://github.com/CesiumGS/cesium/pull/13302.
-        collectionPositions,
-        vertexOffset * 3,
-        scratchPosition,
-      );
+/**
+ * @param {BufferPolylineCollection} collection
+ * @param {number} collectionIndex
+ * @param {TypedArray} collectionPositions
+ * @param {TypedArray} indices
+ * @param {FeatureFactoryFn} getFeature
+ * @ignore
+ */
+function appendBufferPolylines(
+  collection,
+  collectionIndex,
+  collectionPositions,
+  indices,
+  getFeature,
+) {
+  const restartIndex = getPrimitiveRestartIndex(indices);
+
+  let lineIndexStart = 0;
+  let lineIndexCount = 0;
+  let primitiveIndex = 0;
+
+  for (let i = 0; i < indices.length; i++) {
+    // Iteration has reached the end of a line strip primitive if the current
+    // index is a "restart index", or the next index is out of bounds.
+    const index = indices[i];
+    if (index === restartIndex) {
+      lineIndexCount = i - lineIndexStart;
+    } else if (i + 1 === indices.length) {
+      lineIndexCount = i + 1 - lineIndexStart;
+    }
 
-      const pickObject = getFeature(vertexOffset);
-      pickObject.addPrimitiveByCollection(collectionIndex, i);
-      const featureId = pickObject.featureId;
+    if (lineIndexCount === 0) {
+      continue;
+    }
 
-      collection.add(
-        { position: scratchPosition, featureId, pickObject },
-        scratchPoint,
-      );
+    const lineIndexEnd = lineIndexStart + lineIndexCount;
+    const lineIndices = indices.subarray(lineIndexStart, lineIndexEnd);
+    const positions = copyArrayByIndices(collectionPositions, lineIndices, 3);
+
+    const feature = getFeature(indices[lineIndexStart]);
+    if (feature) {
+      feature.addPrimitiveByCollection(collectionIndex, primitiveIndex);
     }
-  } 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,
-      );
 
-      const pickObject = getFeature(vertexOffset);
-      pickObject.addPrimitiveByCollection(collectionIndex, i);
-      const featureId = pickObject.featureId;
+    collection.add(
+      { positions, pickObject: feature, featureId: feature?.featureId },
+      scratchPolyline,
+    );
 
-      collection.add({ positions, featureId, pickObject }, scratchPolyline);
-    });
-  } else if (collection instanceof BufferPolygonCollection) {
-    const polygonAttributeOffsets = vector.polygonAttributeOffsets;
-    const polygonIndicesOffsets = vector.polygonIndicesOffsets;
-    const polygonHoleCounts = vector.polygonHoleCounts;
-    const polygonHoleOffsets = vector.polygonHoleOffsets;
-
-    const polygonCount = polygonAttributeOffsets.length;
-    for (let i = 0; i < polygonCount; i++) {
-      const polygonVertexStart = polygonAttributeOffsets[i];
-      const polygonVertexEnd =
-        i + 1 < polygonCount ? polygonAttributeOffsets[i + 1] : vertexCount;
-
-      const positions = collectionPositions.subarray(
-        polygonVertexStart * 3,
-        polygonVertexEnd * 3,
-      );
+    lineIndexStart = i + 1;
+    lineIndexCount = 0;
+    primitiveIndex++;
+  }
+}
 
-      let holes;
-      if (defined(polygonHoleCounts) && polygonHoleCounts[i] > 0) {
-        const holeCount = polygonHoleCounts[i];
-        holes = polygonHoleOffsets.slice(i, i + holeCount);
-        for (let h = 0; h < holeCount; h++) {
-          holes[i] -= polygonVertexStart;
-        }
-      }
+/**
+ * @param {BufferPolygonCollection} collection
+ * @param {number} collectionIndex
+ * @param {TypedArray} collectionPositions
+ * @param {TypedArray} indices
+ * @param {FeatureFactoryFn} getFeature
+ * @param {Vector} vector
+ * @deprecated To be removed after v1.142 release.
+ * @ignore
+ */
+function appendBufferPolygonsDeprecated(
+  collection,
+  collectionIndex,
+  collectionPositions,
+  indices,
+  getFeature,
+  vector,
+) {
+  const polygonAttributeOffsets = vector.polygonAttributeOffsets;
+  const polygonIndicesOffsets = vector.polygonIndicesOffsets;
+  const polygonHoleCounts = vector.polygonHoleCounts;
+  const polygonHoleOffsets = vector.polygonHoleOffsets;
 
-      const triangleIndexStart = polygonIndicesOffsets[i];
-      const triangleIndexEnd =
-        i + 1 < polygonCount ? polygonIndicesOffsets[i + 1] : indices.length;
-      const triangles = indices.slice(triangleIndexStart, triangleIndexEnd);
-      for (let t = 0; t < triangleIndexEnd; t++) {
-        triangles[t] -= polygonVertexStart;
+  const vertexCount = collectionPositions.length / 3;
+  const polygonCount = polygonAttributeOffsets.length;
+  for (let i = 0; i < polygonCount; i++) {
+    const polygonVertexStart = polygonAttributeOffsets[i];
+    const polygonVertexEnd =
+      i + 1 < polygonCount ? polygonAttributeOffsets[i + 1] : vertexCount;
+
+    const positions = collectionPositions.subarray(
+      polygonVertexStart * 3,
+      polygonVertexEnd * 3,
+    );
+
+    let holes;
+    if (defined(polygonHoleCounts) && polygonHoleCounts[i] > 0) {
+      const holeCount = polygonHoleCounts[i];
+      holes = polygonHoleOffsets.slice(i, i + holeCount);
+      for (let h = 0; h < holeCount; h++) {
+        holes[h] -= polygonVertexStart;
       }
+    }
+
+    const triangleIndexStart = polygonIndicesOffsets[i];
+    const triangleIndexEnd =
+      i + 1 < polygonCount ? polygonIndicesOffsets[i + 1] : indices.length;
+    const triangles = indices.slice(triangleIndexStart, triangleIndexEnd);
+    for (let t = 0; t < triangles.length; t++) {
+      triangles[t] -= polygonVertexStart;
+    }
+
+    const feature = getFeature(polygonVertexStart);
+    if (feature) {
+      feature.addPrimitiveByCollection(collectionIndex, i);
+    }
 
-      const pickObject = getFeature(polygonVertexStart);
-      pickObject.addPrimitiveByCollection(collectionIndex, i);
-      const featureId = pickObject.featureId;
+    collection.add(
+      {
+        positions,
+        triangles,
+        holes,
+        pickObject: feature,
+        featureId: feature?.featureId,
+      },
+      scratchPolygon,
+    );
+  }
+}
 
-      collection.add(
-        { positions, triangles, holes, featureId, pickObject },
-        scratchPolygon,
+/**
+ * @param {BufferPolygonCollection} collection
+ * @param {number} collectionIndex
+ * @param {TypedArray} collectionPositions
+ * @param {FeatureFactoryFn} getFeature
+ * @param {Polygon} polygon
+ * @ignore
+ */
+function appendBufferPolygons(
+  collection,
+  collectionIndex,
+  collectionPositions,
+  getFeature,
+  polygon,
+) {
+  // Create mapping from vertex index in the source glTF primitive, to result
+  // vertex index in the extracted vector primitive.
+  const TypedArray = /** @type {TypedArrayConstructor} */ (
+    polygon.loopIndices.constructor
+  );
+  const resultLoopIndices = new TypedArray(polygon.loopIndices.length);
+
+  const loopRestartIndex = getPrimitiveRestartIndex(polygon.loopIndices);
+
+  for (let i = 0; i < polygon.count; i++) {
+    const isLastPolygon = i + 1 === polygon.count;
+
+    // Extract vertex loops, exterior loops followed by interior ("holes").
+    const loopIndicesStart = polygon.loopIndicesOffsets[i];
+    const loopIndicesEnd = isLastPolygon
+      ? polygon.loopIndices.length
+      : polygon.loopIndicesOffsets[i + 1];
+    const loopIndices = polygon.loopIndices.subarray(
+      loopIndicesStart,
+      loopIndicesEnd,
+    );
+    const positions = copyArrayByIndices(
+      collectionPositions,
+      loopIndices,
+      3,
+      resultLoopIndices,
+    );
+
+    // List start indices of interior loops ("holes").
+    const holesArray = [];
+    for (let j = 0; j < loopIndices.length; j++) {
+      const isLastIndex = j + 1 === loopIndices.length;
+      if (loopIndices[j] === loopRestartIndex && !isLastIndex) {
+        holesArray.push(j);
+      }
+    }
+    const holes = new TypedArray(holesArray);
+
+    // Extract or tessellate triangle indices.
+    let triangles;
+    if (defined(polygon.triangleIndices)) {
+      const triangleIndicesStart = polygon.triangleIndicesOffsets[i];
+      const triangleIndicesEnd = isLastPolygon
+        ? polygon.triangleIndices.length
+        : polygon.triangleIndicesOffsets[i + 1];
+      triangles = polygon.triangleIndices.subarray(
+        triangleIndicesStart,
+        triangleIndicesEnd,
       );
+      // Rewrite collection-local indices to polygon-local indices.
+      for (let j = 0; j < triangles.length; j++) {
+        triangles[j] = resultLoopIndices[triangles[j]];
+      }
+    } else {
+      throw new Error("Runtime triangulation not yet supported.");
+    }
+
+    const feature = getFeature(loopIndices[0]);
+    if (feature) {
+      feature.addPrimitiveByCollection(collectionIndex, i);
     }
+
+    collection.add(
+      {
+        positions,
+        triangles,
+        holes,
+        pickObject: feature,
+        featureId: feature?.featureId,
+      },
+      scratchPolygon,
+    );
   }
 }
 
@@ -324,45 +567,65 @@ function appendNodeToBuffers(content, node, parentTransform, result) {
   for (let i = 0; i < primitives.length; i++) {
     const primitive = primitives[i];
     const primitiveType = primitive.primitiveType;
-    if (!primitive.vector) {
-      continue;
-    }
 
     /** @type {BufferPrimitiveCollection<BufferPrimitive>} */
     let collection;
 
     const stats = gatherPrimitiveStats(primitive);
 
+    const positionAttribute = ModelUtility.getAttributeBySemantic(
+      primitive,
+      VertexAttributeSemantic.POSITION,
+    );
+    const positionNormalized = positionAttribute.normalized ?? false;
+    const positionDatatype = positionAttribute.componentDatatype;
+
     if (primitiveType === PrimitiveType.POINTS) {
       collection = new BufferPointCollection({
         primitiveCountMax: stats.pointPrimitiveCount,
         allowPicking: true,
+        positionNormalized,
+        positionDatatype,
       });
     } else if (primitiveType === PrimitiveType.LINE_STRIP) {
       collection = new BufferPolylineCollection({
         primitiveCountMax: stats.polylinePrimitiveCount,
         vertexCountMax: stats.polylineVertexCount,
         allowPicking: true,
+        positionNormalized,
+        positionDatatype,
       });
-    } else if (primitiveType === PrimitiveType.TRIANGLES) {
+    } else if (
+      primitiveType === PrimitiveType.TRIANGLES ||
+      primitiveType === PrimitiveType.LINE_LOOP
+    ) {
       collection = new BufferPolygonCollection({
         primitiveCountMax: stats.polygonPrimitiveCount,
         vertexCountMax: stats.polygonVertexCount,
         holeCountMax: stats.polygonHoleCount,
         triangleCountMax: stats.polygonTriangleCount,
         allowPicking: true,
+        positionNormalized,
+        positionDatatype,
       });
     }
 
+    const featureIdComponent = primitive.featureIds?.[0];
+    const propertyTableId = featureIdComponent?.propertyTableId;
+    if (!result.featuresByTableId.has(propertyTableId)) {
+      result.featuresByTableId.set(propertyTableId, new Map());
+    }
+
     result.collections.push(collection);
     result.collectionLocalMatrices.push(Matrix4.clone(nodeTransform));
+    result.collectionFeatureTableIds.set(collection, propertyTableId);
 
     appendPrimitiveToBuffers(
       content,
       primitive,
       collection,
       result.collections.length - 1,
-      result.features,
+      result.featuresByTableId.get(propertyTableId),
     );
   }
 
@@ -372,4 +635,57 @@ function appendNodeToBuffers(content, node, parentTransform, result) {
   }
 }
 
+/**
+ * Given a source array and a list of indices, creates and returns a new array
+ * containing all values of the source array specified by the indices. Indices
+ * may contain "primitive restart index" values. Optionally, a 'resultIndices'
+ * parameter can be populated with a mapping from source index to result index.
+ *
+ * @param {TypedArray} array
+ * @param {TypedArray} indices
+ * @param {number} stride
+ * @param {TypedArray} [resultIndices]
+ * @returns {TypedArray}
+ * @ignore
+ */
+function copyArrayByIndices(array, indices, stride, resultIndices) {
+  const restartIndex = getPrimitiveRestartIndex(indices);
+
+  // Scan and count the number of non-restart indices.
+  let count = 0;
+  for (let i = 0; i < indices.length; i++) {
+    const index = indices[i];
+    if (index !== restartIndex) {
+      count++;
+    }
+  }
+
+  const TypedArray = /** @type {TypedArrayConstructor} */ (array.constructor);
+  const result = new TypedArray(count * stride);
+
+  // Write each result value, skipping primitive restart indices. Write source
+  // index -> result index to 'resultIndices' if provided.
+  let dstIndex = 0;
+  for (let i = 0; i < indices.length; i++) {
+    const srcIndex = indices[i];
+
+    if (resultIndices) {
+      resultIndices[srcIndex] =
+        srcIndex === restartIndex ? restartIndex : dstIndex;
+    }
+
+    if (srcIndex === restartIndex) {
+      continue;
+    }
+
+    for (let j = 0; j < stride; j++) {
+      result[dstIndex * stride + j] = array[srcIndex * stride + j];
+    }
+
+    dstIndex++;
+  }
+
+  return result;
+}
+
 export default createVectorTileBuffersFromModelComponents;