@hztxi/cesium-engine 25.0.6 → 26.2.1

package/Source/Scene/Model/createVectorTileBuffersFromModelComponents.js

@@ -1,7 +1,7 @@
 // @ts-check
 
 import Cartesian3 from "../../Core/Cartesian3.js";
-import assert from "../../Core/assert.js";
+import CesiumMath from "../../Core/Math.js";
 import defined from "../../Core/defined.js";
 import Matrix4 from "../../Core/Matrix4.js";
 import PrimitiveType from "../../Core/PrimitiveType.js";
@@ -16,13 +16,16 @@ import VertexAttributeSemantic from "../VertexAttributeSemantic.js";
 import ModelReader from "./ModelReader.js";
 import ModelUtility from "./ModelUtility.js";
 import ModelComponents from "../ModelComponents.js";
+import SceneMode from "../SceneMode.js";
+import SceneTransforms from "../SceneTransforms.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 FrameState from "../FrameState.js"; */
+/** @import {Attribute, Components, Node, Polygon, Primitive, Vector} from "../ModelComponents.js"; */
 
 /**
  * @typedef {object} VectorTileResult
@@ -34,6 +37,12 @@ import Cesium3DTileVectorFeature from "../Cesium3DTileVectorFeature.js";
  */
 
 const scratchPosition = new Cartesian3();
+const scratchWorldPosition = new Cartesian3();
+const scratchProjectedPosition = new Cartesian3();
+const scratchReferenceWorldPosition = new Cartesian3();
+const scratchReferenceProjectedPosition = new Cartesian3();
+const scratchProjectedMinimum = new Cartesian3();
+const scratchProjectedMaximum = new Cartesian3();
 const scratchPoint = new BufferPoint();
 const scratchPolyline = new BufferPolyline();
 const scratchPolygon = new BufferPolygon();
@@ -43,12 +52,22 @@ const scratchPolygon = new BufferPolygon();
  *
  * @param {VectorGltf3DTileContent} content
  * @param {Components} components
+ * @param {FrameState} frameState
  * @returns {VectorTileResult}
  *
  * @ignore
  */
-function createVectorTileBuffersFromModelComponents(content, components) {
+function createVectorTileBuffersFromModelComponents(
+  content,
+  components,
+  frameState,
+) {
   const rootNodes = components.scene.nodes;
+  const tileModelMatrix = Matrix4.multiplyTransformation(
+    content._tile.computedTransform,
+    content._modelMatrix,
+    new Matrix4(),
+  );
 
   /** @type {VectorTileResult} */
   const result = {
@@ -59,7 +78,14 @@ function createVectorTileBuffersFromModelComponents(content, components) {
   };
 
   for (let i = 0; i < rootNodes.length; i++) {
-    appendNodeToBuffers(content, rootNodes[i], Matrix4.IDENTITY, result);
+    appendNodeToBuffers(
+      content,
+      rootNodes[i],
+      Matrix4.IDENTITY,
+      tileModelMatrix,
+      frameState,
+      result,
+    );
   }
 
   return result;
@@ -74,25 +100,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
@@ -110,6 +117,7 @@ function gatherPrimitiveStats(primitive) {
   };
 
   const vector = primitive.vector;
+  const polygon = primitive.polygon;
   const primitiveType = primitive.primitiveType;
   const positionAttribute = ModelUtility.getAttributeBySemantic(
     primitive,
@@ -122,29 +130,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}`);
@@ -153,12 +165,35 @@ 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
  * @param {BufferPrimitiveCollection<BufferPrimitive>} collection
  * @param {number} collectionIndex
  * @param {Map<number, Cesium3DTileVectorFeature>} features
+ * @param {Matrix4} modelMatrix
+ * @param {FrameState} frameState
  * @ignore
  */
 function appendPrimitiveToBuffers(
@@ -167,8 +202,9 @@ function appendPrimitiveToBuffers(
   collection,
   collectionIndex,
   features,
+  modelMatrix,
+  frameState,
 ) {
-  const vector = primitive.vector;
   const positionAttribute = ModelUtility.getAttributeBySemantic(
     primitive,
     VertexAttributeSemantic.POSITION,
@@ -176,134 +212,499 @@ function appendPrimitiveToBuffers(
   /** @type {TypedArray} */
   const collectionPositions =
     positionAttribute.typedArray ??
-    ModelReader.readAttributeAsTypedArray(positionAttribute);
-  const vertexCount = collectionPositions.length / 3;
+    (collection.positionNormalized
+      ? ModelReader.readAttributeAsRawCompactTypedArray(positionAttribute)
+      : ModelReader.readAttributeAsTypedArray(positionAttribute));
+
+  const projection =
+    frameState.mode === SceneMode.SCENE3D
+      ? undefined
+      : projectPositionsFor2D(collectionPositions, modelMatrix, frameState);
+  const collectionPositionsToAppend =
+    projection?.positions ?? collectionPositions;
 
   /** @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,
+      collectionPositionsToAppend,
+      indices,
+      getFeature,
+    );
+  } else if (collection instanceof BufferPolylineCollection) {
+    appendBufferPolylines(
+      collection,
+      collectionIndex,
+      collectionPositionsToAppend,
+      indices,
+      getFeature,
+    );
+  } else if (collection instanceof BufferPolygonCollection) {
+    if (defined(primitive.vector)) {
+      appendBufferPolygonsDeprecated(
+        collection,
+        collectionIndex,
+        collectionPositionsToAppend,
+        indices,
+        getFeature,
+        primitive.vector,
+      );
+    } else {
+      appendBufferPolygons(
+        collection,
+        collectionIndex,
+        collectionPositionsToAppend,
+        getFeature,
+        primitive.polygon,
+      );
+    }
+  }
+
+  return projection?.referencePoint;
+}
+
+/**
+ * @param {TypedArray} positions
+ * @param {Matrix4} modelMatrix
+ * @param {FrameState} frameState
+ * @returns {{positions: TypedArray, referencePoint: Cartesian3}}
+ * @ignore
+ */
+function projectPositionsFor2D(positions, modelMatrix, frameState) {
+  const projectedPositions = positions.slice();
+  const mode = frameState.mode;
+  const worldWidth =
+    CesiumMath.TWO_PI * frameState.mapProjection.ellipsoid.maximumRadius;
+
+  // Use the model origin as the reference longitude. Vertices exactly on the
+  // antimeridian can be converted to either -PI or PI depending on tiny
+  // floating-point differences. Without a shared reference, those vertices
+  // produce triangles that span the entire width of the map in 2D.
+  let referenceEasting;
+  if (mode === SceneMode.COLUMBUS_VIEW || mode === SceneMode.SCENE2D) {
+    Matrix4.getTranslation(modelMatrix, scratchReferenceWorldPosition);
+    const referenceProjected = SceneTransforms.computeActualEllipsoidPosition(
+      frameState,
+      scratchReferenceWorldPosition,
+      scratchReferenceProjectedPosition,
+    );
+    if (defined(referenceProjected)) {
+      referenceEasting = referenceProjected.y;
+    }
+  }
+
+  const minimum = Cartesian3.fromElements(
+    Number.POSITIVE_INFINITY,
+    Number.POSITIVE_INFINITY,
+    Number.POSITIVE_INFINITY,
+    scratchProjectedMinimum,
+  );
+  const maximum = Cartesian3.fromElements(
+    Number.NEGATIVE_INFINITY,
+    Number.NEGATIVE_INFINITY,
+    Number.NEGATIVE_INFINITY,
+    scratchProjectedMaximum,
+  );
+  let projectedCount = 0;
+
+  for (let i = 0; i < positions.length; i += 3) {
+    // @ts-expect-error https://github.com/CesiumGS/cesium/pull/13302
+    Cartesian3.fromArray(projectedPositions, i, scratchPosition);
+    Matrix4.multiplyByPoint(modelMatrix, scratchPosition, scratchWorldPosition);
+    const projected = SceneTransforms.computeActualEllipsoidPosition(
+      frameState,
+      scratchWorldPosition,
+      scratchProjectedPosition,
+    );
+    if (!defined(projected)) {
+      continue;
+    }
+
+    if (defined(referenceEasting)) {
+      const eastingOffset = projected.y - referenceEasting;
+      projected.y -=
+        getWorldCopyOffset(eastingOffset / worldWidth) * worldWidth;
+    }
+
+    Cartesian3.minimumByComponent(projected, minimum, minimum);
+    Cartesian3.maximumByComponent(projected, maximum, maximum);
+    projectedCount++;
+    projectedPositions[i] = projected.x;
+    projectedPositions[i + 1] = projected.y;
+    projectedPositions[i + 2] = projected.z;
+  }
+
+  if (projectedCount === 0) {
+    throw new RuntimeError(
+      "Failed to project vector tile positions to the current scene mode.",
+    );
+  }
+
+  const referencePoint = Cartesian3.add(minimum, maximum, new Cartesian3());
+  Cartesian3.multiplyByScalar(referencePoint, 0.5, referencePoint);
+
+  for (let i = 0; i < positions.length; i += 3) {
+    projectedPositions[i] -= referencePoint.x;
+    projectedPositions[i + 1] -= referencePoint.y;
+    projectedPositions[i + 2] -= referencePoint.z;
+  }
+
+  return {
+    positions: projectedPositions,
+    referencePoint,
+  };
+}
+
+/**
+ * Selects the world copy nearest to the collection reference. Exact half-world
+ * offsets are kept in the current copy instead of being rounded outward.
+ * Otherwise a vertex exactly at +180 degrees can be shifted to the -180 degree
+ * copy while the rest of its ring remains on the east side, producing
+ * triangles that span the entire map in 2D.
+ *
+ * @param {number} value Offset from the reference in world widths.
+ * @returns {number} The selected world copy.
+ * @ignore
+ */
+function getWorldCopyOffset(value) {
+  const nearest = Math.round(value);
+  if (Math.abs(value - nearest) === 0.5) {
+    return Math.trunc(value);
+  }
+  return nearest;
+}
 
-  /** @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;
+    }
+
+    if (lineIndexCount === 0) {
+      continue;
+    }
 
-      const pickObject = getFeature(vertexOffset);
-      pickObject.addPrimitiveByCollection(collectionIndex, i);
-      const featureId = pickObject.featureId;
+    const lineIndexEnd = lineIndexStart + lineIndexCount;
+    const lineIndices = indices.subarray(lineIndexStart, lineIndexEnd);
+    const positions = copyArrayByIndices(collectionPositions, lineIndices, 3);
 
-      collection.add(
-        { position: scratchPosition, featureId, pickObject },
-        scratchPoint,
-      );
+    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;
+  collection._polygonTileBoundaryFlags = vector.polygonTileBoundaryFlags;
 
-      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;
+  let polygonHoleOffset = 0;
+  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(
+        polygonHoleOffset,
+        polygonHoleOffset + holeCount,
+      );
+      for (let h = 0; h < holeCount; h++) {
+        holes[h] -= polygonVertexStart;
       }
+      polygonHoleOffset += holeCount;
+    }
 
-      const pickObject = getFeature(polygonVertexStart);
-      pickObject.addPrimitiveByCollection(collectionIndex, i);
-      const featureId = pickObject.featureId;
+    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);
+    }
 
-      collection.add(
-        { positions, triangles, holes, featureId, pickObject },
-        scratchPolygon,
+    collection.add(
+      {
+        positions,
+        triangles,
+        holes,
+        pickObject: feature,
+        featureId: feature?.featureId,
+      },
+      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 = [];
+    let resultVertexOffset = 0;
+    for (let j = 0; j < loopIndices.length; j++) {
+      const isLastIndex = j + 1 === loopIndices.length;
+      if (loopIndices[j] === loopRestartIndex && !isLastIndex) {
+        holesArray.push(resultVertexOffset);
+      } else {
+        resultVertexOffset++;
+      }
+    }
+    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,
+    );
   }
 }
 
@@ -311,10 +712,19 @@ function appendPrimitiveToBuffers(
  * @param {VectorGltf3DTileContent} content
  * @param {Node} node
  * @param {Matrix4} parentTransform
+ * @param {Matrix4} tileModelMatrix
+ * @param {FrameState} frameState
  * @param {VectorTileResult} result
  * @ignore
  */
-function appendNodeToBuffers(content, node, parentTransform, result) {
+function appendNodeToBuffers(
+  content,
+  node,
+  parentTransform,
+  tileModelMatrix,
+  frameState,
+  result,
+) {
   const localTransform = ModelUtility.getNodeTransform(node);
   const nodeTransform = Matrix4.multiplyTransformation(
     parentTransform,
@@ -326,33 +736,46 @@ 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,
       });
     }
 
@@ -363,22 +786,91 @@ function appendNodeToBuffers(content, node, parentTransform, result) {
     }
 
     result.collections.push(collection);
-    result.collectionLocalMatrices.push(Matrix4.clone(nodeTransform));
-    result.collectionFeatureTableIds.set(collection, propertyTableId);
-
-    appendPrimitiveToBuffers(
+    const referencePoint = appendPrimitiveToBuffers(
       content,
       primitive,
       collection,
       result.collections.length - 1,
       result.featuresByTableId.get(propertyTableId),
+      Matrix4.multiplyTransformation(
+        tileModelMatrix,
+        nodeTransform,
+        new Matrix4(),
+      ),
+      frameState,
+    );
+    result.collectionLocalMatrices.push(
+      defined(referencePoint)
+        ? Matrix4.fromTranslation(referencePoint, new Matrix4())
+        : Matrix4.clone(nodeTransform),
     );
+    result.collectionFeatureTableIds.set(collection, propertyTableId);
   }
 
   const children = node.children;
   for (let i = 0; i < children.length; i++) {
-    appendNodeToBuffers(content, children[i], nodeTransform, result);
+    appendNodeToBuffers(
+      content,
+      children[i],
+      nodeTransform,
+      tileModelMatrix,
+      frameState,
+      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;