@loaders.gl/tile-converter 4.0.0-alpha.5 → 4.0.0-alpha.7

package/src/i3s-converter/helpers/coordinate-converter.ts

@@ -1,15 +1,15 @@
-import type {BoundingVolumes, Extent, Mbs, Obb} from '@loaders.gl/i3s';
+import type {BoundingVolumes, FullExtent, Mbs, Obb} from '@loaders.gl/i3s';
 
 import {Matrix3, Quaternion, Vector3} from '@math.gl/core';
 import {Ellipsoid} from '@math.gl/geospatial';
 import {
   OrientedBoundingBox,
   makeOrientedBoundingBoxFromPoints,
-  makeBoundingSphereFromPoints
+  makeBoundingSphereFromPoints,
+  BoundingSphere
 } from '@math.gl/culling';
-import TileHeader from '@loaders.gl/tiles/src/tileset/tile-3d';
+import {Tile3D} from '@loaders.gl/tiles';
 import {Geoid} from '@math.gl/geoid';
-import {Tileset3D} from '@loaders.gl/tiles';
 
 /**
  * Create bounding volumes object from tile and geoid height model.
@@ -17,7 +17,7 @@ import {Tileset3D} from '@loaders.gl/tiles';
  * @param geoidHeightModel
  * @returns - Bounding volumes object
  */
-export function createBoundingVolumes(tile: TileHeader, geoidHeightModel: Geoid): BoundingVolumes {
+export function createBoundingVolumes(tile: Tile3D, geoidHeightModel: Geoid): BoundingVolumes {
   let radius;
   let halfSize;
   let quaternion;
@@ -101,34 +101,41 @@ export function convertPositionsToVectors(positions: Float32Array): Vector3[] {
 }
 
 /**
- * Convert common coordinate to extent coordinate
- * @param tileset
- * @returns - Extent
- * @todo why lodMetricValue is radius? need to check this function
+ * Convert common coordinate to fullExtent https://github.com/Esri/i3s-spec/blob/master/docs/1.8/fullExtent.cmn.md
+ * @param
+ * @param boundingVolume
+ * @returns - fullExtent object
  */
-export function convertCommonToI3SExtentCoordinate(tileset: Tileset3D | null): Extent | null {
-  const cartesianCenter = tileset?.cartesianCenter;
-  if (!cartesianCenter) {
-    return null;
+export function convertBoundingVolumeToI3SFullExtent(
+  boundingVolume: OrientedBoundingBox | BoundingSphere
+): FullExtent {
+  let sphere: BoundingSphere;
+  if (boundingVolume instanceof BoundingSphere) {
+    sphere = boundingVolume;
+  } else {
+    sphere = boundingVolume.getBoundingSphere();
   }
-  const radius = tileset?.lodMetricValue;
-  const rightTop = Ellipsoid.WGS84.cartesianToCartographic(
-    new Vector3(cartesianCenter[0] + radius, cartesianCenter[1] + radius, cartesianCenter[2]),
+  const center: Vector3 = sphere.center;
+  const radius: number = sphere.radius;
+  const vertexMax = Ellipsoid.WGS84.cartesianToCartographic(
+    new Vector3(center[0] + radius, center[1] + radius, center[2] + radius),
     new Vector3()
   );
-  const leftBottom = Ellipsoid.WGS84.cartesianToCartographic(
-    new Vector3(cartesianCenter[0] - radius, cartesianCenter[1] - radius, cartesianCenter[2]),
+  const vertexMin = Ellipsoid.WGS84.cartesianToCartographic(
+    new Vector3(center[0] - radius, center[1] - radius, center[2] - radius),
     new Vector3()
   );
-  const isFirstRight = rightTop[0] < leftBottom[0];
-  const isFirstTop = rightTop[1] < leftBottom[1];
 
-  return [
-    isFirstRight ? rightTop[0] : leftBottom[0],
-    isFirstTop ? rightTop[1] : leftBottom[1],
-    isFirstRight ? leftBottom[0] : rightTop[0],
-    isFirstTop ? leftBottom[1] : rightTop[1]
-  ];
+  // Converter sometimes returns min values that are bigger then max,
+  // so we should check and take bigger value from max and smaller for nim
+  return {
+    xmin: Math.min(vertexMin[0], vertexMax[0]),
+    xmax: Math.max(vertexMin[0], vertexMax[0]),
+    ymin: Math.min(vertexMin[1], vertexMax[1]),
+    ymax: Math.max(vertexMin[1], vertexMax[1]),
+    zmin: Math.min(vertexMin[2], vertexMax[2]),
+    zmax: Math.max(vertexMin[2], vertexMax[2])
+  };
 }
 
 /**

package/src/i3s-converter/helpers/create-scene-server-path.ts

@@ -1,3 +1,4 @@
+import type {SceneLayer3D} from '@loaders.gl/i3s';
 import {v4 as uuidv4} from 'uuid';
 import transform from 'json-map-transform';
 import {join} from 'path';
@@ -7,12 +8,15 @@ import {writeFile} from '../../lib/utils/file-utils';
 
 /**
  * Form and save sceneServer meta data into a file
- * @param {string} layerName - layer name to display
- * @param {object} layers0 - layer object embedded into sceneServer meta data
- * @param {string} rootPath - root path of new converted tileset
- * @return {promise}
+ * @param layerName - layer name to display
+ * @param layers0 - layer object embedded into sceneServer meta data
+ * @param rootPath - root path of new converted tileset
  */
-export async function createSceneServerPath(layerName, layers0, rootPath) {
+export async function createSceneServerPath(
+  layerName: string,
+  layers0: SceneLayer3D,
+  rootPath: string
+): Promise<void> {
   const sceneServerData = {
     serviceItemId: uuidv4().replace(/-/gi, ''),
     layerName,

package/src/i3s-converter/helpers/feature-attributes.ts

@@ -0,0 +1,247 @@
+import type {FeatureTableJson} from '@loaders.gl/3d-tiles';
+import {
+  Attribute,
+  AttributeStorageInfo,
+  ESRIField,
+  Field,
+  FieldInfo,
+  PopupInfo
+} from '@loaders.gl/i3s';
+
+/**
+ * Takes attributes from property table based on featureIds.
+ * If there is no property value for particular featureId (index) the property will be null.
+ * Example:
+ * Initial data:
+ *   OBJECTID: [0, 1, 5]
+ *   component: ['Windows', 'Frames', 'Wall', 'Roof', 'Skylight']
+ * Result:
+ *   OBJECTID: [0, 1, 5]
+ *   component: ['Windows', 'Frames', 'null']
+ * @param featureIds
+ * @param propertyTable
+ */
+export function flattenPropertyTableByFeatureIds(
+  featureIds: number[],
+  propertyTable: FeatureTableJson
+): FeatureTableJson {
+  const resultPropertyTable: FeatureTableJson = {};
+  for (const propertyName in propertyTable) {
+    const properties = propertyTable[propertyName];
+    resultPropertyTable[propertyName] = getPropertiesByFeatureIds(properties, featureIds);
+  }
+
+  return resultPropertyTable;
+}
+
+/**
+ * Getting properties by featureId index
+ * @param properties
+ * @param featureIds
+ */
+function getPropertiesByFeatureIds(properties: any[], featureIds: number[]): any[] {
+  const resultProperties: any = [];
+
+  for (const featureId of featureIds) {
+    const property = properties[featureId] || null;
+    resultProperties.push(property);
+  }
+
+  return resultProperties;
+}
+
+/**
+ * Check that all attributes in propertyTable have the same length as FeatureIds.
+ * If there are differencies between lengths we should flatten property table based on exiesting featureIds.
+ * @param featureIds
+ * @param propertyTable
+ * @returns
+ */
+export function checkPropertiesLength(
+  featureIds: number[],
+  propertyTable: FeatureTableJson
+): boolean {
+  let needFlatten = false;
+
+  for (const attribute of Object.values(propertyTable)) {
+    if (featureIds.length !== attribute.length) {
+      needFlatten = true;
+    }
+  }
+
+  return needFlatten;
+}
+
+/** String data type name for feature attributes */
+const STRING_TYPE = 'string';
+/** Integer data type name for feature attributes */
+const SHORT_INT_TYPE = 'Int32';
+/** Double data type name for feature attributes */
+const DOUBLE_TYPE = 'double';
+/** Type of attribute that is linked with feature ids */
+const OBJECT_ID_TYPE = 'OBJECTID';
+/**
+ * Get the attribute type for attributeStorageInfo https://github.com/Esri/i3s-spec/blob/master/docs/1.7/attributeStorageInfo.cmn.md
+ * @param key - attribute's key
+ * @param attribute - attribute's type in propertyTable
+ */
+export function getAttributeType(key: string, attribute: string): string {
+  if (key === OBJECT_ID_TYPE) {
+    return OBJECT_ID_TYPE;
+  }
+  if (typeof attribute === STRING_TYPE) {
+    return STRING_TYPE;
+  } else if (typeof attribute === 'number') {
+    return Number.isInteger(attribute) ? SHORT_INT_TYPE : DOUBLE_TYPE;
+  }
+  return STRING_TYPE;
+}
+
+/**
+ * Generate storage attribute for map segmentation.
+ * @param attributeIndex - order index of attribute (f_0, f_1 ...).
+ * @param key - attribute key from propertyTable.
+ * @param attributeType - attribute type.
+ * @return Updated storageAttribute.
+ */
+export function createdStorageAttribute(
+  attributeIndex: number,
+  key: string,
+  attributeType: Attribute
+): AttributeStorageInfo {
+  const storageAttribute = {
+    key: `f_${attributeIndex}`,
+    name: key,
+    ordering: ['attributeValues'],
+    header: [{property: 'count', valueType: 'UInt32'}],
+    attributeValues: {valueType: 'Int32', valuesPerElement: 1}
+  };
+
+  switch (attributeType) {
+    case OBJECT_ID_TYPE:
+      setupIdAttribute(storageAttribute);
+      break;
+    case STRING_TYPE:
+      setupStringAttribute(storageAttribute);
+      break;
+    case DOUBLE_TYPE:
+      setupDoubleAttribute(storageAttribute);
+      break;
+    case SHORT_INT_TYPE:
+      break;
+    default:
+      setupStringAttribute(storageAttribute);
+  }
+
+  return storageAttribute;
+}
+
+/**
+ * Find and return attribute type based on key form propertyTable.
+ * @param attributeType
+ */
+export function getFieldAttributeType(attributeType: Attribute): ESRIField {
+  switch (attributeType) {
+    case OBJECT_ID_TYPE:
+      return 'esriFieldTypeOID';
+    case STRING_TYPE:
+      return 'esriFieldTypeString';
+    case SHORT_INT_TYPE:
+      return 'esriFieldTypeInteger';
+    case DOUBLE_TYPE:
+      return 'esriFieldTypeDouble';
+    default:
+      return 'esriFieldTypeString';
+  }
+}
+
+/**
+ * Setup field attribute for map segmentation.
+ * @param key - attribute for map segmentation.
+ * @param fieldAttributeType - esri attribute type ('esriFieldTypeString' or 'esriFieldTypeOID').
+ */
+export function createFieldAttribute(key: string, fieldAttributeType: ESRIField): Field {
+  return {
+    name: key,
+    type: fieldAttributeType,
+    alias: key
+  };
+}
+
+/**
+ * Generate popup info to show metadata on the map.
+ * @param propertyTable - table data with OBJECTID.
+ * @return data for correct rendering of popup.
+ */
+export function createPopupInfo(propertyTable: FeatureTableJson): PopupInfo {
+  const title = '{OBJECTID}';
+  const mediaInfos = [];
+  const fieldInfos: FieldInfo[] = [];
+  const popupElements: {
+    fieldInfos: FieldInfo[];
+    type: string;
+  }[] = [];
+  const expressionInfos = [];
+
+  for (const key in propertyTable) {
+    fieldInfos.push({
+      fieldName: key,
+      visible: true,
+      isEditable: false,
+      label: key
+    });
+  }
+  popupElements.push({
+    fieldInfos,
+    type: 'fields'
+  });
+
+  return {
+    title,
+    mediaInfos,
+    popupElements,
+    fieldInfos,
+    expressionInfos
+  };
+}
+
+/**
+ * Setup storage attribute as string.
+ * @param storageAttribute - attribute for map segmentation.
+ */
+function setupStringAttribute(storageAttribute: AttributeStorageInfo): void {
+  // @ts-expect-error
+  storageAttribute.ordering.unshift('attributeByteCounts');
+  storageAttribute.header.push({property: 'attributeValuesByteCount', valueType: 'UInt32'});
+  storageAttribute.attributeValues = {
+    valueType: 'String',
+    encoding: 'UTF-8',
+    valuesPerElement: 1
+  };
+  storageAttribute.attributeByteCounts = {
+    valueType: 'UInt32',
+    valuesPerElement: 1
+  };
+}
+
+/**
+ * Setup Id attribute for map segmentation.
+ * @param storageAttribute - attribute for map segmentation .
+ */
+function setupIdAttribute(storageAttribute: AttributeStorageInfo): void {
+  storageAttribute.attributeValues = {
+    valueType: 'Oid32',
+    valuesPerElement: 1
+  };
+}
+
+/**
+ * Setup double attribute for map segmentation.
+ * @param storageAttribute - attribute for map segmentation .
+ */
+function setupDoubleAttribute(storageAttribute: AttributeStorageInfo): void {
+  storageAttribute.attributeValues = {
+    valueType: 'Float64',
+    valuesPerElement: 1
+  };
+}

package/src/i3s-converter/helpers/geometry-attributes.ts

@@ -1,3 +1,4 @@
+import type {GeometryAttributes, ConvertedAttributes, GroupedByFeatureIdAttributes} from '../types';
 import {concatenateTypedArrays} from '@loaders.gl/loader-utils';
 
 const VALUES_PER_VERTEX = 3;
@@ -5,11 +6,12 @@ const POSITIONS_AND_NORMALS_PER_TRIANGLE = 9;
 
 /**
  * Generate geometry attributes with faceRange and featureCount
- * @param {Object} attributes
- * @returns {Object} Object with featureCount, reordered attributes and changed faceRange.
+ * @param attributes
+ * @returns attirbutes with featureCount, featureIds and changed faceRange.
  */
-export function generateAttributes(attributes) {
-  const {positions, normals, texCoords, colors, featureIndices, triangleCount} = attributes;
+export function generateAttributes(attributes: ConvertedAttributes): GeometryAttributes {
+  const {positions, normals, texCoords, colors, uvRegions, featureIndices} = attributes;
+  const triangleCount = positions.length / POSITIONS_AND_NORMALS_PER_TRIANGLE;
 
   if (!featureIndices.length) {
     return {
@@ -19,28 +21,34 @@ export function generateAttributes(attributes) {
       positions,
       normals,
       texCoords,
-      colors
+      colors,
+      uvRegions
     };
   }
 
-  const {faceRange, featureCount, featureIds} = calculateFaceRangesAndFeaturesCount(featureIndices);
-  const attributeObjects = makeAttributeObjects({faceRange, featureIds, ...attributes});
+  const data = calculateFaceRangesAndFeaturesCount(featureIndices);
+  const attributeObjects = makeAttributeObjects({...data, ...attributes});
   const unifiedAttributeObjectsByFeatureIds = unifyObjectsByFeatureId(attributeObjects);
   const groupedAttributes = groupAttributesAndRangesByFeatureId(
-    unifiedAttributeObjectsByFeatureIds
+    unifiedAttributeObjectsByFeatureIds,
+    data.featureCount
   );
-  return {featureCount, ...groupedAttributes};
+  return groupedAttributes;
 }
 
 /**
  * Calculates face Ranges and feature count based on featureIndices.
- * @param {Object} featureIndices
- * @returns {Object} Object with featureCount, reordered attributes and changed faceRange.
+ * @param featureIndices
+ * @returns Object with featureCount, reordered attributes and changed faceRange.
  */
-function calculateFaceRangesAndFeaturesCount(featureIndices) {
+function calculateFaceRangesAndFeaturesCount(featureIndices: number[]): {
+  faceRange: Uint32Array;
+  featureCount: number;
+  featureIds: number[];
+} {
   let rangeIndex = 1;
   let featureIndex = 1;
-  let currentFeatureId = featureIndices[0];
+  let currentFeatureId = getFrequentValue(featureIndices.slice(0, VALUES_PER_VERTEX));
   const faceRangeList: any[] = [];
   const featureIds: any[] = [];
   const uniqueFeatureIds = [currentFeatureId];
@@ -48,20 +56,21 @@ function calculateFaceRangesAndFeaturesCount(featureIndices) {
   faceRangeList[0] = 0;
   featureIds[0] = currentFeatureId;
 
-  for (let index = 1; index < featureIndices.length; index++) {
-    if (currentFeatureId !== featureIndices[index]) {
+  for (let index = VALUES_PER_VERTEX; index < featureIndices.length; index += VALUES_PER_VERTEX) {
+    const newFeatureId = getFrequentValue(featureIndices.slice(index, index + VALUES_PER_VERTEX));
+    if (currentFeatureId !== newFeatureId) {
       faceRangeList[rangeIndex] = index / VALUES_PER_VERTEX - 1;
       faceRangeList[rangeIndex + 1] = index / VALUES_PER_VERTEX;
-      featureIds[featureIndex] = featureIndices[index];
+      featureIds[featureIndex] = newFeatureId;
 
-      if (!uniqueFeatureIds.includes(featureIndices[index])) {
-        uniqueFeatureIds.push(featureIndices[index]);
+      if (!uniqueFeatureIds.includes(newFeatureId)) {
+        uniqueFeatureIds.push(newFeatureId);
       }
 
       rangeIndex += 2;
       featureIndex += 1;
     }
-    currentFeatureId = featureIndices[index];
+    currentFeatureId = newFeatureId;
   }
 
   faceRangeList[rangeIndex] = featureIndices.length / VALUES_PER_VERTEX - 1;
@@ -72,29 +81,59 @@ function calculateFaceRangesAndFeaturesCount(featureIndices) {
   return {faceRange, featureCount, featureIds};
 }
 
+/**
+ * Find most frequent value to avoid situation where one vertex can be part of multiple features (objects).
+ * @param values
+ */
+function getFrequentValue(values: number[]): number {
+  const map: {[key: number]: number} = {};
+
+  let mostFrequentValue = values[0];
+  let maxCount = 1;
+
+  for (const value of values) {
+    // Save item and it's frequency count to the map.
+    map[value] = (map[value] || 0) + 1;
+    // Find max count of frequency.
+    maxCount = maxCount > map[value] ? maxCount : map[value];
+    // Find the most frequent value.
+    mostFrequentValue = maxCount > map[value] ? mostFrequentValue : value;
+  }
+
+  return mostFrequentValue;
+}
+
 /**
  * Generate list of attribute object grouped by feature ids.
- * @param {Object} attributes
- * @returns {Array} sorted list of attribute objects.
+ * @param  attributes
+ * @returns sorted list of attribute objects.
  */
-function makeAttributeObjects(attributes) {
-  const {featureIds, positions, normals, colors, texCoords, faceRange} = attributes;
-  const groupedData: any[] = [];
+function makeAttributeObjects(attributes: GeometryAttributes): GroupedByFeatureIdAttributes[] {
+  const {
+    featureIds,
+    positions,
+    normals,
+    colors,
+    uvRegions,
+    texCoords,
+    faceRange = new Uint32Array(0)
+  } = attributes;
+  const groupedData: GroupedByFeatureIdAttributes[] = [];
 
   let positionsList = new Float32Array(positions);
   let normalsList = new Float32Array(normals);
   let colorsList = new Uint8Array(colors);
   let texCoordsList = new Float32Array(texCoords);
-
-  let faceRangeIndex = 0;
+  let uvRegionsList = new Uint16Array(uvRegions);
 
   for (let index = 0; index < featureIds.length; index++) {
-    const startIndex = faceRange[index + faceRangeIndex];
-    const endIndex = faceRange[index + faceRangeIndex + 1];
+    const startIndex = faceRange[index * 2];
+    const endIndex = faceRange[index * 2 + 1];
 
     const positionsCount = getSliceAttributeCount('positions', startIndex, endIndex);
     const normalsCount = getSliceAttributeCount('normals', startIndex, endIndex);
     const colorsCount = getSliceAttributeCount('colors', startIndex, endIndex);
+    const uvRegionsCount = getSliceAttributeCount('uvRegions', startIndex, endIndex);
     const texCoordsCount = getSliceAttributeCount('texCoords', startIndex, endIndex);
 
     groupedData.push({
@@ -102,15 +141,15 @@ function makeAttributeObjects(attributes) {
       positions: positionsList.slice(0, positionsCount),
       normals: normalsList.slice(0, normalsCount),
       colors: colorsList.slice(0, colorsCount),
+      uvRegions: uvRegionsList.slice(0, uvRegionsCount),
       texCoords: texCoordsList.slice(0, texCoordsCount)
     });
 
     positionsList = positionsList.slice(positionsCount);
     normalsList = normalsList.slice(normalsCount);
     colorsList = colorsList.slice(colorsCount);
+    uvRegionsList = uvRegionsList.slice(uvRegionsCount);
     texCoordsList = texCoordsList.slice(texCoordsCount);
-
-    faceRangeIndex += 1;
   }
 
   return groupedData.sort((first, second) => first.featureId - second.featureId);
@@ -118,13 +157,17 @@ function makeAttributeObjects(attributes) {
 
 /**
  * Generate sliced count for generating attribute objects depends on attribute name and range.
- * @param {String} attributeName
- * @param {Number} startIndex
- * @param {Number} endIndex
- * @returns {Number} - sliced count
+ * @param attributeName
+ * @param startIndex
+ * @param endIndex
+ * @returns sliced count
  */
-function getSliceAttributeCount(attributeName, startIndex, endIndex) {
-  const colorsPerVertex = 4;
+function getSliceAttributeCount(
+  attributeName: string,
+  startIndex: number,
+  endIndex: number
+): number {
+  const itemsPerVertex4 = 4;
   const texCoordsPerVertex = 2;
 
   const trianglesCount = endIndex - startIndex + 1;
@@ -135,7 +178,8 @@ function getSliceAttributeCount(attributeName, startIndex, endIndex) {
     case 'normals':
       return trianglesCount * POSITIONS_AND_NORMALS_PER_TRIANGLE;
     case 'colors':
-      return vertexCount * colorsPerVertex;
+    case 'uvRegions':
+      return vertexCount * itemsPerVertex4;
     case 'texCoords':
       return vertexCount * texCoordsPerVertex;
     default:
@@ -145,11 +189,13 @@ function getSliceAttributeCount(attributeName, startIndex, endIndex) {
 
 /**
  * Generates unique object list depends on feature ids and concantenate their attributes.
- * @param {Array} sortedData
- * @returns {Array} - unique list of objects
+ * @param sortedData
+ * @returns unique list of objects
  */
-function unifyObjectsByFeatureId(sortedData) {
-  const uniqueObjects: any[] = [];
+function unifyObjectsByFeatureId(
+  sortedData: GroupedByFeatureIdAttributes[]
+): GroupedByFeatureIdAttributes[] {
+  const uniqueObjects: GroupedByFeatureIdAttributes[] = [];
 
   for (let index = 0; index < sortedData.length; index++) {
     const currentObject = sortedData[index];
@@ -176,16 +222,20 @@ function unifyObjectsByFeatureId(sortedData) {
 
 /**
  * Generates attribute objects with new faceRange and reordered attributes.
- * @param {Array} unifiedObjects
- * @returns {Object} - ugenerated attributes with new faceRange.
+ * @param unifiedObjects
+ * @returns generated attributes with new faceRange.
  */
-function groupAttributesAndRangesByFeatureId(unifiedObjects) {
+function groupAttributesAndRangesByFeatureId(
+  unifiedObjects: GroupedByFeatureIdAttributes[],
+  featureCount: number
+): GeometryAttributes {
   const firstAttributeObject = unifiedObjects[0];
-  const featureIds = [firstAttributeObject.featureId];
+  const featureIds = [firstAttributeObject.featureId || 0];
 
   let positions = new Float32Array(firstAttributeObject.positions);
   let normals = new Float32Array(firstAttributeObject.normals);
   let colors = new Uint8Array(firstAttributeObject.colors);
+  let uvRegions = new Uint16Array(firstAttributeObject.uvRegions);
   let texCoords = new Float32Array(firstAttributeObject.texCoords);
   const range = [0];
 
@@ -194,11 +244,12 @@ function groupAttributesAndRangesByFeatureId(unifiedObjects) {
 
   for (let index = 1; index < unifiedObjects.length; index++) {
     const currentAttributesObject = unifiedObjects[index];
-    featureIds.push(currentAttributesObject.featureId);
+    featureIds.push(currentAttributesObject.featureId || 0);
 
     positions = concatenateTypedArrays(positions, currentAttributesObject.positions);
     normals = concatenateTypedArrays(normals, currentAttributesObject.normals);
     colors = concatenateTypedArrays(colors, currentAttributesObject.colors);
+    uvRegions = concatenateTypedArrays(uvRegions, currentAttributesObject.uvRegions);
     texCoords = concatenateTypedArrays(texCoords, currentAttributesObject.texCoords);
 
     const groupedObject = unifiedObjects[objIndex];
@@ -212,5 +263,5 @@ function groupAttributesAndRangesByFeatureId(unifiedObjects) {
   range.push(positions.length / POSITIONS_AND_NORMALS_PER_TRIANGLE - 1);
 
   const faceRange = new Uint32Array(range);
-  return {faceRange, featureIds, positions, normals, colors, texCoords};
+  return {faceRange, featureIds, positions, normals, colors, uvRegions, texCoords, featureCount};
 }