@loaders.gl/tile-converter 4.0.0-alpha.9 → 4.0.0-beta.2

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

@@ -1,13 +1,13 @@
 import type {FeatureTableJson, Tiles3DTileContent} from '@loaders.gl/3d-tiles';
 import type {
-  GLTF_EXT_feature_metadata,
-  GLTF_EXT_mesh_features,
   GLTFAccessorPostprocessed,
   GLTFMaterialPostprocessed,
   GLTFNodePostprocessed,
   GLTFMeshPrimitivePostprocessed,
   GLTFMeshPostprocessed,
-  GLTFTexturePostprocessed
+  GLTFTexturePostprocessed,
+  GLTF_EXT_feature_metadata_GLTF,
+  GLTF_EXT_structural_metadata_GLTF
 } from '@loaders.gl/gltf';
 
 import {Vector3, Matrix4, Vector4} from '@math.gl/core';
@@ -35,13 +35,8 @@ import {
 } from '@loaders.gl/i3s';
 import {NumberArray, TypedArray} from '@loaders.gl/loader-utils';
 import {Geoid} from '@math.gl/geoid';
-/** Usage of worker here brings more overhead than advantage */
-import {
-  B3DMAttributesData /*, transformI3SAttributesOnWorker*/,
-  TextureImageProperties
-} from '../../i3s-attributes-worker';
 import {prepareDataForAttributesConversion} from './gltf-attributes';
-import {handleBatchIdsExtensions} from './batch-ids-extensions';
+import {getTextureByMetadataClass, handleBatchIdsExtensions} from './batch-ids-extensions';
 import {checkPropertiesLength, flattenPropertyTableByFeatureIds} from './feature-attributes';
 import {GL} from '@loaders.gl/math';
 
@@ -50,10 +45,17 @@ import {GL} from '@loaders.gl/math';
   So the following import is replaced with the local import
   import type {TypedArrayConstructor} from '@math.gl/types'; 
 */
-import type {TypedArrayConstructor} from '../types';
+import type {GLTFAttributesData, TextureImageProperties, TypedArrayConstructor} from '../types';
 import {generateSyntheticIndices} from '../../lib/utils/geometry-utils';
 import {BoundingSphere, OrientedBoundingBox} from '@math.gl/culling';
 
+import {
+  EXT_FEATURE_METADATA,
+  EXT_STRUCTURAL_METADATA,
+  getPropertyTableFromExtFeatureMetadata,
+  getPropertyTableFromExtStructuralMetadata
+} from '@loaders.gl/gltf';
+
 // Spec - https://github.com/Esri/i3s-spec/blob/master/docs/1.7/pbrMetallicRoughness.cmn.md
 const DEFAULT_ROUGHNESS_FACTOR = 1;
 const DEFAULT_METALLIC_FACTOR = 1;
@@ -73,9 +75,6 @@ const OBJECT_ID_TYPE = 'Oid32';
  */
 const BATCHED_ID_POSSIBLE_ATTRIBUTE_NAMES = ['CUSTOM_ATTRIBUTE_2', '_BATCHID', 'BATCHID'];
 
-const EXT_FEATURE_METADATA = 'EXT_feature_metadata';
-const EXT_MESH_FEATURES = 'EXT_mesh_features';
-
 let scratchVector = new Vector3();
 
 /**
@@ -93,7 +92,8 @@ let scratchVector = new Vector3();
  * @param generateBoundingVolumes - is converter should create accurate bounding voulmes from geometry attributes
  * @param shouldMergeMaterials - Try to merge similar materials to be able to merge meshes into one node
  * @param geoidHeightModel - model to convert elevation from elipsoidal to geoid
- * @param workerSource - source code of used workers
+ * @param libraries - dynamicaly loaded 3rd-party libraries
+ * @param metadataClass `- user selected feature metadata class name`
  * @returns Array of node resources to create one or more i3s nodes
  */
 export default async function convertB3dmToI3sGeometry(
@@ -108,7 +108,8 @@ export default async function convertB3dmToI3sGeometry(
   generateBoundingVolumes: boolean,
   shouldMergeMaterials: boolean,
   geoidHeightModel: Geoid,
-  workerSource: {[key: string]: string}
+  libraries: Record<string, string>,
+  metadataClass?: string
 ): Promise<I3SConvertedResources[] | null> {
   const useCartesianPositions = generateBoundingVolumes;
   const materialAndTextureList: I3SMaterialWithTexture[] = await convertMaterials(
@@ -121,10 +122,12 @@ export default async function convertB3dmToI3sGeometry(
     tileTransform,
     tileBoundingVolume
   );
+  const featureTexture = getTextureByMetadataClass(tileContent, metadataClass);
   const convertedAttributesMap: Map<string, ConvertedAttributes> = await convertAttributes(
     dataForAttributesConversion,
     materialAndTextureList,
-    useCartesianPositions
+    useCartesianPositions,
+    featureTexture
   );
   /** Usage of worker here brings more overhead than advantage */
   // const convertedAttributesMap: Map<string, ConvertedAttributes> =
@@ -162,7 +165,7 @@ export default async function convertB3dmToI3sGeometry(
         propertyTable,
         attributeStorageInfo,
         draco,
-        workerSource
+        libraries
       })
     );
   }
@@ -214,7 +217,7 @@ function _generateBoundingVolumesFromGeometry(
  * @param params.propertyTable - batch table (corresponding to feature attributes data)
  * @param params.attributeStorageInfo - attributes metadata from 3DSceneLayer json
  * @param params.draco - is converter should create draco compressed geometry
- * @param params.workerSource - source code of used workers
+ * @param libraries - dynamicaly loaded 3rd-party libraries
  * @returns Array of I3S node resources
  */
 async function _makeNodeResources({
@@ -227,7 +230,7 @@ async function _makeNodeResources({
   propertyTable,
   attributeStorageInfo,
   draco,
-  workerSource
+  libraries
 }: {
   convertedAttributes: ConvertedAttributes;
   material: I3SMaterialDefinition;
@@ -238,19 +241,25 @@ async function _makeNodeResources({
   propertyTable: FeatureTableJson | null;
   attributeStorageInfo?: AttributeStorageInfo[];
   draco: boolean;
-  workerSource: {[key: string]: string};
+  libraries: Record<string, string>;
 }): Promise<I3SConvertedResources> {
   const boundingVolumes = convertedAttributes.boundingVolumes;
   const vertexCount = convertedAttributes.positions.length / VALUES_PER_VERTEX;
   const {faceRange, featureIds, positions, normals, colors, uvRegions, texCoords, featureCount} =
     generateAttributes(convertedAttributes);
 
-  if (tileContent.batchTableJson) {
-    makeFeatureIdsUnique(
+  let featureIdsMap: Record<string, number> = {};
+  if (propertyTable) {
+    /**
+     * 3DTiles has featureIndices unique only for one tile.
+     * In I3S featureIds are unique layer-wide. We create featureIds from all feature properties.
+     * If 3DTiles features has equal set of properties they are considered as same feature in I3S.
+     */
+    featureIdsMap = makeFeatureIdsUnique(
       featureIds,
       convertedAttributes.featureIndices,
       featuresHashArray,
-      tileContent.batchTableJson
+      propertyTable
     );
   }
 
@@ -283,7 +292,7 @@ async function _makeNodeResources({
           featureIds,
           faceRange
         },
-        workerSource.draco
+        libraries
       )
     : null;
 
@@ -292,6 +301,7 @@ async function _makeNodeResources({
   if (attributeStorageInfo && propertyTable) {
     attributes = convertPropertyTableToAttributeBuffers(
       featureIds,
+      featureIdsMap,
       propertyTable,
       attributeStorageInfo
     );
@@ -318,12 +328,14 @@ async function _makeNodeResources({
  * @param materialAndTextureList - array of data about materials and textures of the content
  * @param useCartesianPositions - convert positions to absolute cartesian coordinates instead of cartographic offsets.
  * Cartesian coordinates will be required for creating bounding voulmest from geometry positions
+ * @param featureTexture - feature texture key
  * @returns map of converted geometry attributes
  */
 export async function convertAttributes(
-  attributesData: B3DMAttributesData,
+  attributesData: GLTFAttributesData,
   materialAndTextureList: I3SMaterialWithTexture[],
-  useCartesianPositions: boolean
+  useCartesianPositions: boolean,
+  featureTexture: string | null
 ): Promise<Map<string, ConvertedAttributes>> {
   const {nodes, images, cartographicOrigin, cartesianModelMatrix} = attributesData;
   const attributesMap = new Map<string, ConvertedAttributes>();
@@ -351,7 +363,9 @@ export async function convertAttributes(
     cartographicOrigin,
     cartesianModelMatrix,
     attributesMap,
-    useCartesianPositions
+    useCartesianPositions,
+    undefined,
+    featureTexture
   );
 
   for (const attrKey of attributesMap.keys()) {
@@ -375,7 +389,7 @@ export async function convertAttributes(
 }
 
 /**
- * Gltf has hierarchical structure of nodes. This function converts nodes starting from those which are in gltf scene object.
+ * glTF has hierarchical structure of nodes. This function converts nodes starting from those which are in gltf scene object.
  *   The goal is applying tranformation matrix for all children. Functions "convertNodes" and "convertNode" work together recursively.
  * @param nodes - gltf nodes array
  * @param images - gltf images array
@@ -385,6 +399,7 @@ export async function convertAttributes(
  * @param useCartesianPositions - convert positions to absolute cartesian coordinates instead of cartographic offsets.
  * Cartesian coordinates will be required for creating bounding voulmest from geometry positions
  * @param matrix - transformation matrix - cumulative transformation matrix formed from all parent node matrices
+ * @param featureTexture - feature texture key
  * @returns {void}
  */
 function convertNodes(
@@ -394,7 +409,8 @@ function convertNodes(
   cartesianModelMatrix: Matrix4,
   attributesMap: Map<string, ConvertedAttributes>,
   useCartesianPositions: boolean,
-  matrix: Matrix4 = new Matrix4([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1])
+  matrix: Matrix4 = new Matrix4([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]),
+  featureTexture: string | null
 ) {
   if (nodes) {
     for (const node of nodes) {
@@ -405,7 +421,8 @@ function convertNodes(
         cartesianModelMatrix,
         attributesMap,
         useCartesianPositions,
-        matrix
+        matrix,
+        featureTexture
       );
     }
   }
@@ -447,11 +464,12 @@ function getCompositeTransformationMatrix(node: GLTFNodePostprocessed, matrix: M
  * @param images - gltf images array
  * @param cartographicOrigin - cartographic origin of bounding volume
  * @param cartesianModelMatrix - cartesian model matrix to convert coordinates to cartographic
- * @param {Map} attributesMap Map<{positions: Float32Array, normals: Float32Array, texCoords: Float32Array, colors: Uint8Array, featureIndices: Array}> - for recursive concatenation of
+ * @param attributesMap Map<{positions: Float32Array, normals: Float32Array, texCoords: Float32Array, colors: Uint8Array, featureIndices: Array}> - for recursive concatenation of
  *   attributes
  * @param useCartesianPositions - convert positions to absolute cartesian coordinates instead of cartographic offsets.
  * Cartesian coordinates will be required for creating bounding voulmest from geometry positions
- * @param {Matrix4} matrix - transformation matrix - cumulative transformation matrix formed from all parent node matrices
+ * @param matrix - transformation matrix - cumulative transformation matrix formed from all parent node matrices
+ * @param featureTexture - feature texture key
  */
 function convertNode(
   node: GLTFNodePostprocessed,
@@ -460,7 +478,8 @@ function convertNode(
   cartesianModelMatrix: Matrix4,
   attributesMap: Map<string, ConvertedAttributes>,
   useCartesianPositions,
-  matrix = new Matrix4([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1])
+  matrix = new Matrix4([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]),
+  featureTexture: string | null
 ) {
   const transformationMatrix = getCompositeTransformationMatrix(node, matrix);
 
@@ -474,7 +493,8 @@ function convertNode(
       cartesianModelMatrix,
       attributesMap,
       useCartesianPositions,
-      transformationMatrix
+      transformationMatrix,
+      featureTexture
     );
   }
 
@@ -485,7 +505,8 @@ function convertNode(
     cartesianModelMatrix,
     attributesMap,
     useCartesianPositions,
-    transformationMatrix
+    transformationMatrix,
+    featureTexture
   );
 }
 
@@ -497,12 +518,12 @@ function convertNode(
  * @param cartesianModelMatrix - cartesian model matrix to convert coordinates to cartographic
  * @param attributesMap Map<{positions: Float32Array, normals: Float32Array, texCoords: Float32Array, colors: Uint8Array, featureIndices: Array}> - for recursive concatenation of
  *   attributes
- * @param useCartesianPositions - convert positions to absolute cartesian coordinates instead of cartographic offsets. 
+ * @param useCartesianPositions - convert positions to absolute cartesian coordinates instead of cartographic offsets.
  * Cartesian coordinates will be required for creating bounding voulmest from geometry positions
  * @param attributesMap Map<{positions: Float32Array, normals: Float32Array, texCoords: Float32Array, colors: Uint8Array, featureIndices: Array}> - for recursive concatenation of
  *   attributes
- 
- * @param {Matrix4} matrix - transformation matrix - cumulative transformation matrix formed from all parent node matrices
+ * @param matrix - transformation matrix - cumulative transformation matrix formed from all parent node matrices
+ * @param featureTexture - feature texture key
  */
 function convertMesh(
   mesh: GLTFMeshPostprocessed,
@@ -511,7 +532,8 @@ function convertMesh(
   cartesianModelMatrix: Matrix4,
   attributesMap: Map<string, ConvertedAttributes>,
   useCartesianPositions = false,
-  matrix = new Matrix4([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1])
+  matrix = new Matrix4([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]),
+  featureTexture: string | null
 ) {
   for (const primitive of mesh.primitives) {
     let outputAttributes: ConvertedAttributes | null | undefined = null;
@@ -582,7 +604,7 @@ function convertMesh(
 
     outputAttributes.featureIndicesGroups = outputAttributes.featureIndicesGroups || [];
     outputAttributes.featureIndicesGroups.push(
-      flattenBatchIds(getBatchIds(attributes, primitive, images), indices)
+      flattenBatchIds(getBatchIds(attributes, primitive, images, featureTexture), indices)
     );
   }
 }
@@ -809,15 +831,23 @@ function flattenBatchIds(batchedIds: NumberArray, indices: TypedArray): number[]
  * @param attributes - gltf accessors
  * @param primitive - gltf primitive data
  * @param images - gltf texture images
+ * @param featureTexture - feature texture key
+ * @return batch IDs
  */
 function getBatchIds(
   attributes: {
     [key: string]: GLTFAccessorPostprocessed;
   },
   primitive: GLTFMeshPrimitivePostprocessed,
-  images: (TextureImageProperties | null)[]
+  images: (TextureImageProperties | null)[],
+  featureTexture: string | null
 ): NumberArray {
-  const batchIds: NumberArray = handleBatchIdsExtensions(attributes, primitive, images);
+  const batchIds: NumberArray = handleBatchIdsExtensions(
+    attributes,
+    primitive,
+    images,
+    featureTexture
+  );
 
   if (batchIds.length) {
     return batchIds;
@@ -1027,7 +1057,7 @@ function convertMaterial(sourceMaterial: GLTFMaterialPostprocessed): I3SMaterial
 
 /**
  * Converts from `alphaMode` material property from GLTF to I3S format
- * @param gltfAlphaMode Gltf material `alphaMode` property
+ * @param gltfAlphaMode glTF material `alphaMode` property
  * @returns I3SMaterialDefinition.alphaMode property
  */
 function convertAlphaMode(
@@ -1233,17 +1263,18 @@ function generateImageId(texture: GLTFTexturePostprocessed, nodeId: number) {
  * @param featureIndices
  * @param featuresHashArray
  * @param batchTable
- * @returns {void}
+ * @returns propertyTable indices to map featureIds
  */
 function makeFeatureIdsUnique(
   featureIds: number[],
   featureIndices: number[],
   featuresHashArray: string[],
   batchTable: {[key: string]: any}
-) {
+): Record<string, number> {
   const replaceMap = getFeaturesReplaceMap(featureIds, batchTable, featuresHashArray);
   replaceIndicesByUnique(featureIndices, replaceMap);
   replaceIndicesByUnique(featureIds, replaceMap);
+  return replaceMap;
 }
 
 /**
@@ -1257,8 +1288,8 @@ function getFeaturesReplaceMap(
   featureIds: any[],
   batchTable: object,
   featuresHashArray: any[]
-): Record<string, any> {
-  const featureMap: Record<string, any> = {};
+): Record<string, number> {
+  const featureMap: Record<string, number> = {};
 
   for (let index = 0; index < featureIds.length; index++) {
     const oldFeatureId = featureIds[index];
@@ -1310,7 +1341,7 @@ function getOrCreateUniqueFeatureId(
  * @param featureMap
  * @returns
  */
-function replaceIndicesByUnique(indicesArray: any[], featureMap: Record<string, []>) {
+function replaceIndicesByUnique(indicesArray: number[], featureMap: Record<string, number>) {
   for (let index = 0; index < indicesArray.length; index++) {
     indicesArray[index] = featureMap[indicesArray[index]];
   }
@@ -1325,6 +1356,7 @@ function replaceIndicesByUnique(indicesArray: any[], featureMap: Record<string,
  */
 function convertPropertyTableToAttributeBuffers(
   featureIds: number[],
+  featureIdsMap: Record<string, number>,
   propertyTable: FeatureTableJson,
   attributeStorageInfo: AttributeStorageInfo[]
 ): any[] {
@@ -1332,7 +1364,7 @@ function convertPropertyTableToAttributeBuffers(
 
   const needFlattenPropertyTable = checkPropertiesLength(featureIds, propertyTable);
   const properties = needFlattenPropertyTable
-    ? flattenPropertyTableByFeatureIds(featureIds, propertyTable)
+    ? flattenPropertyTableByFeatureIds(featureIdsMap, propertyTable)
     : propertyTable;
 
   const propertyTableWithObjectIds = {
@@ -1342,10 +1374,12 @@ function convertPropertyTableToAttributeBuffers(
 
   for (const propertyName in propertyTableWithObjectIds) {
     const type = getAttributeType(propertyName, attributeStorageInfo);
-    const value = propertyTableWithObjectIds[propertyName];
-    const attributeBuffer = generateAttributeBuffer(type, value);
+    if (type) {
+      const value = propertyTableWithObjectIds[propertyName];
+      const attributeBuffer = generateAttributeBuffer(type, value);
 
-    attributeBuffers.push(attributeBuffer);
+      attributeBuffers.push(attributeBuffer);
+    }
   }
 
   return attributeBuffers;
@@ -1385,6 +1419,20 @@ function generateAttributeBuffer(type: string, value: any): ArrayBuffer {
  */
 function getAttributeType(key: string, attributeStorageInfo: any[]): string {
   const attribute = attributeStorageInfo.find((attr) => attr.name === key);
+  if (!attribute) {
+    console.error(
+      `attribute is null, key=${key}, attributeStorageInfo=${JSON.stringify(
+        attributeStorageInfo,
+        null,
+        2
+      )}`
+    );
+    return '';
+  }
+  if (!attribute.attributeValues) {
+    console.error(`attributeValues is null, attribute=${attribute}`);
+    return '';
+  }
   return attribute.attributeValues.valueType;
 }
 
@@ -1457,17 +1505,17 @@ function generateBigUint64Array(featureIds: any[]): BigUint64Array {
 
 /**
  * Generates draco compressed geometry
- * @param {Number} vertexCount
- * @param {Object} convertedAttributes - get rid of this argument here
- * @param {Object} attributes - geometry attributes to compress
- * @param {string} dracoWorkerSoure - draco worker source code
- * @returns {Promise<object>} - COmpressed geometry.
+ * @param vertexCount
+ * @param convertedAttributes - get rid of this argument here
+ * @param attributes - geometry attributes to compress
+ * @param libraries - dynamicaly loaded 3rd-party libraries
+ * @returns - Compressed geometry.
  */
 async function generateCompressedGeometry(
   vertexCount: number,
   convertedAttributes: Record<string, any>,
   attributes: Record<string, any>,
-  dracoWorkerSoure: string
+  libraries: Record<string, string>
 ): Promise<ArrayBuffer> {
   const {positions, normals, texCoords, colors, uvRegions, featureIds, faceRange} = attributes;
   const indices = new Uint32Array(vertexCount);
@@ -1516,12 +1564,17 @@ async function generateCompressedGeometry(
 
   return encode({attributes: compressedAttributes, indices}, DracoWriterWorker, {
     ...DracoWriterWorker.options,
-    source: dracoWorkerSoure,
     reuseWorkers: true,
     _nodeWorkers: true,
+    modules: libraries,
+    useLocalLibraries: true,
     draco: {
       method: 'MESH_SEQUENTIAL_ENCODING',
       attributesMetadata
+    },
+    ['draco-writer']: {
+      // We need to load local fs workers because nodejs can't load workers from the Internet
+      workerUrl: './modules/draco/dist/draco-writer-worker-node.js'
     }
   });
 }
@@ -1556,14 +1609,18 @@ function generateFeatureIndexAttribute(
  * Find property table in tile
  * For example it can be batchTable for b3dm files or property table in gLTF extension.
  * @param tileContent - 3DTiles tile content
- * @return batch table from b3dm / feature properties from EXT_FEATURE_METADATA
+ * @param metadataClass - user selected feature metadata class name
+ * @return batch table from b3dm / feature properties from EXT_FEATURE_METADATA or EXT_STRUCTURAL_METADATA.
  */
-export function getPropertyTable(tileContent: Tiles3DTileContent | null): FeatureTableJson | null {
+export function getPropertyTable(
+  tileContent: Tiles3DTileContent | null,
+  metadataClass?: string
+): FeatureTableJson | null {
   if (!tileContent) {
     return null;
   }
-
-  const batchTableJson = tileContent?.batchTableJson;
+  let propertyTable: FeatureTableJson | null;
+  const batchTableJson = tileContent.batchTableJson;
 
   if (batchTableJson) {
     return batchTableJson;
@@ -1572,12 +1629,19 @@ export function getPropertyTable(tileContent: Tiles3DTileContent | null): Featur
   const {extensionName, extension} = getPropertyTableExtension(tileContent);
 
   switch (extensionName) {
-    case EXT_MESH_FEATURES: {
-      console.warn('The I3S converter does not yet support the EXT_mesh_features extension');
-      return null;
+    case EXT_STRUCTURAL_METADATA: {
+      propertyTable = getPropertyTableFromExtStructuralMetadata(
+        extension as GLTF_EXT_structural_metadata_GLTF,
+        metadataClass
+      );
+      return propertyTable;
     }
     case EXT_FEATURE_METADATA: {
-      return getPropertyTableFromExtFeatureMetadata(extension as GLTF_EXT_feature_metadata);
+      propertyTable = getPropertyTableFromExtFeatureMetadata(
+        extension as GLTF_EXT_feature_metadata_GLTF,
+        metadataClass
+      );
+      return propertyTable;
     }
     default:
       return null;
@@ -1588,10 +1652,11 @@ export function getPropertyTable(tileContent: Tiles3DTileContent | null): Featur
  * Check extensions which can be with property table inside.
  * @param tileContent - 3DTiles tile content
  */
-function getPropertyTableExtension(
-  tileContent: Tiles3DTileContent
-): GLTF_EXT_feature_metadata | GLTF_EXT_mesh_features {
-  const extensionsWithPropertyTables = [EXT_FEATURE_METADATA, EXT_MESH_FEATURES];
+function getPropertyTableExtension(tileContent: Tiles3DTileContent): {
+  extensionName: null | string;
+  extension: string | GLTF_EXT_feature_metadata_GLTF | GLTF_EXT_structural_metadata_GLTF | null;
+} {
+  const extensionsWithPropertyTables = [EXT_FEATURE_METADATA, EXT_STRUCTURAL_METADATA];
   const extensionsUsed = tileContent?.gltf?.extensionsUsed;
 
   if (!extensionsUsed) {
@@ -1599,69 +1664,27 @@ function getPropertyTableExtension(
   }
 
   let extensionName: string = '';
-
   for (const extensionItem of tileContent?.gltf?.extensionsUsed || []) {
     if (extensionsWithPropertyTables.includes(extensionItem)) {
       extensionName = extensionItem;
+      /*
+        It returns the first extension containing the property table.
+        We assume that there can be only one extension containing the property table:
+        either EXT_FEATURE_METADATA, which is a depricated extension,
+        or EXT_STRUCTURAL_METADATA.
+      */
       break;
     }
   }
 
-  const extension = tileContent?.gltf?.extensions?.[extensionName];
-
-  return {extensionName, extension};
-}
-
-/**
- * Handle EXT_feature_metadata to get property table
- * @param extension
- */
-function getPropertyTableFromExtFeatureMetadata(
-  extension: GLTF_EXT_feature_metadata
-): FeatureTableJson | null {
-  if (extension?.featureTables) {
-    /**
-     * Take only first feature table to generate attributes storage info object.
-     * TODO: Think about getting data from all feature tables?
-     * It can be tricky just because 3dTiles is able to have multiple featureId attributes and multiple feature tables.
-     * In I3S we should decide which featureIds attribute will be passed to geometry data.
-     */
-    const firstFeatureTableName = Object.keys(extension.featureTables)?.[0];
-
-    if (firstFeatureTableName) {
-      const featureTable = extension?.featureTables[firstFeatureTableName];
-      const propertyTable = {};
-
-      for (const propertyName in featureTable.properties) {
-        propertyTable[propertyName] = featureTable.properties[propertyName].data;
-      }
-
-      return propertyTable;
-    }
+  if (!extensionName) {
+    return {extensionName: null, extension: null};
   }
 
-  if (extension?.featureTextures) {
-    /**
-     * Take only first feature texture to generate attributes storage info object.
-     * TODO: Think about getting data from all feature textures?
-     * It can be tricky just because 3dTiles is able to have multiple featureTextures.
-     * In I3S we should decide which featureTextures will be passed to geometry data.
-     */
-    const firstTextureName = Object.keys(extension.featureTextures)?.[0];
-    if (firstTextureName) {
-      const featureTable = extension?.featureTextures[firstTextureName];
-      const propertyTable = {};
+  const extension = tileContent?.gltf?.extensions?.[extensionName] as
+    | string // EXT_mesh_features doesn't have global metadata
+    | GLTF_EXT_feature_metadata_GLTF
+    | GLTF_EXT_structural_metadata_GLTF;
 
-      for (const propertyName in featureTable.properties) {
-        propertyTable[propertyName] = featureTable.properties[propertyName].data;
-      }
-
-      return propertyTable;
-    }
-  }
-
-  console.warn(
-    "The I3S converter couldn't handle EXT_feature_metadata extension: There is neither featureTables, no featureTextures in the extension."
-  );
-  return null;
+  return {extensionName, extension};
 }

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

@@ -1,13 +1,9 @@
 import type {Tiles3DTileContent} from '@loaders.gl/3d-tiles';
 import type {GLTFAccessorPostprocessed, GLTFNodePostprocessed} from '@loaders.gl/gltf';
-import type {B3DMAttributesData} from '../../i3s-attributes-worker';
-import {Matrix4, Vector3} from '@math.gl/core';
+import {Matrix4, TypedArray, Vector3} from '@math.gl/core';
 import {BoundingSphere, OrientedBoundingBox} from '@math.gl/culling';
 import {Ellipsoid} from '@math.gl/geospatial';
-
-type AttributesObject = {
-  [k: string]: GLTFAccessorPostprocessed;
-};
+import {GLTFAttributesData} from '../types';
 
 /**
  * Prepare attributes for conversion to avoid binary data breaking in worker thread.
@@ -15,13 +11,13 @@ type AttributesObject = {
  * @param tileTransform - transformation matrix of the tile, calculated recursively multiplying
  *                        transform of all parent tiles and transform of the current tile
  * @param boundingVolume - initialized bounding volume of the source tile
- * @returns
+ * @returns 3DTiles content data, prepared for conversion
  */
 export function prepareDataForAttributesConversion(
   tileContent: Tiles3DTileContent,
   tileTransform: Matrix4,
   boundingVolume: OrientedBoundingBox | BoundingSphere
-): B3DMAttributesData {
+): GLTFAttributesData {
   let nodes =
     tileContent.gltf?.scene?.nodes ||
     tileContent.gltf?.scenes?.[0]?.nodes ||
@@ -67,9 +63,12 @@ export function prepareDataForAttributesConversion(
 /**
  * Keep only values for glTF attributes to pass data to worker thread.
  * @param attributes - geometry attributes
+ * @returns attributes with only `value` item
  */
-function getB3DMAttributesWithoutBufferView(attributes: AttributesObject): AttributesObject {
-  const attributesWithoutBufferView = {};
+function getB3DMAttributesWithoutBufferView(
+  attributes: Record<string, GLTFAccessorPostprocessed>
+): Record<string, {value: TypedArray}> {
+  const attributesWithoutBufferView: Record<string, {value: TypedArray}> = {};
 
   for (const attributeName in attributes) {
     attributesWithoutBufferView[attributeName] = {