@loaders.gl/tile-converter 3.2.12 → 3.3.0-alpha.10

package/dist/i3s-converter/helpers/geometry-converter.js

@@ -1,18 +1,44 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertAttributes = void 0;
+exports.getPropertyTable = exports.convertAttributes = void 0;
 const core_1 = require("@math.gl/core");
 const geospatial_1 = require("@math.gl/geospatial");
 const draco_1 = require("@loaders.gl/draco");
 const core_2 = require("@loaders.gl/core");
 const loader_utils_1 = require("@loaders.gl/loader-utils");
 const md5_1 = __importDefault(require("md5"));
+const uuid_1 = require("uuid");
 const geometry_attributes_1 = require("./geometry-attributes");
 const coordinate_converter_1 = require("./coordinate-converter");
 const gltf_attributes_1 = require("./gltf-attributes");
+const batch_ids_extensions_1 = require("./batch-ids-extensions");
+const feature_attributes_1 = require("./feature-attributes");
 // 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;
@@ -29,68 +55,64 @@ const OBJECT_ID_TYPE = 'Oid32';
  * BATCHID - Legacy attribute name which includes batch info.
  */
 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 core_1.Vector3();
 /**
  * Convert binary data from b3dm file to i3s resources
  *
  * @param tileContent - 3d tile content
- * @param nodeId - target nodeId. If a few nodes will be created - ids will be nodeId+n where n - index in the resulting array
+ * @param addNodeToNodePage - function to add new node to node pages
+ * @param propertyTable - batch table (corresponding to feature attributes data)
  * @param featuresHashArray - hash array of features that is needed to not to mix up same features in parent and child nodes
  * @param attributeStorageInfo - attributes metadata from 3DSceneLayer json
  * @param draco - is converter should create draco compressed geometry
  * @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
  * @returns Array of node resources to create one or more i3s nodes
  */
-async function convertB3dmToI3sGeometry(tileContent, nodeId, featuresHashArray, attributeStorageInfo, draco, generateBoundingVolumes, geoidHeightModel, workerSource) {
+async function convertB3dmToI3sGeometry(tileContent, addNodeToNodePage, propertyTable, featuresHashArray, attributeStorageInfo, draco, generateBoundingVolumes, shouldMergeMaterials, geoidHeightModel, workerSource) {
     const useCartesianPositions = generateBoundingVolumes;
-    const materialAndTextureList = convertMaterials(tileContent.gltf?.materials);
+    const materialAndTextureList = await convertMaterials(tileContent.gltf?.materials, shouldMergeMaterials);
     const dataForAttributesConversion = (0, gltf_attributes_1.prepareDataForAttributesConversion)(tileContent);
-    const convertedAttributesMap = await convertAttributes(dataForAttributesConversion, useCartesianPositions);
-    // TODO uncomment it when worker will be published on CDN.
-    /*
-    const convertedAttributesMap: Map<string, ConvertedAttributes> =
-      await transformI3SAttributesOnWorker(dataForAttributesConversion, {
-        useCartesianPositions,
-        source: workerSource.I3SAttributes
-      });
-    */
+    const convertedAttributesMap = await convertAttributes(dataForAttributesConversion, materialAndTextureList, useCartesianPositions);
+    /** Usage of worker here brings more overhead than advantage */
+    // const convertedAttributesMap: Map<string, ConvertedAttributes> =
+    //   await transformI3SAttributesOnWorker(dataForAttributesConversion, {
+    //     reuseWorkers: true,
+    //     _nodeWorkers: true,
+    //     useCartesianPositions,
+    //     source: workerSource.I3SAttributes
+    //   });
     if (generateBoundingVolumes) {
         _generateBoundingVolumesFromGeometry(convertedAttributesMap, geoidHeightModel);
     }
-    if (convertedAttributesMap.has('default')) {
-        materialAndTextureList.push({
-            material: getDefaultMaterial()
-        });
-    }
     const result = [];
-    let nodesCounter = nodeId;
-    let { materials = [] } = tileContent.gltf || { materials: [] };
-    if (!materials?.length) {
-        materials.push({ id: 'default' });
-    }
-    for (let i = 0; i < materials.length; i++) {
-        const sourceMaterial = materials[i];
-        if (!convertedAttributesMap.has(sourceMaterial.id)) {
+    for (const materialAndTexture of materialAndTextureList) {
+        const originarMaterialId = materialAndTexture.mergedMaterials[0].originalMaterialId;
+        if (!convertedAttributesMap.has(originarMaterialId)) {
             continue; // eslint-disable-line no-continue
         }
-        const convertedAttributes = convertedAttributesMap.get(sourceMaterial.id);
+        const convertedAttributes = convertedAttributesMap.get(originarMaterialId);
         if (!convertedAttributes) {
             continue;
         }
-        const { material, texture } = materialAndTextureList[i];
+        const { material, texture } = materialAndTexture;
+        const nodeId = await addNodeToNodePage();
         result.push(await _makeNodeResources({
             convertedAttributes,
             material,
             texture,
             tileContent,
-            nodeId: nodesCounter,
+            nodeId,
             featuresHashArray,
+            propertyTable,
             attributeStorageInfo,
             draco,
             workerSource
         }));
-        nodesCounter++;
     }
     if (!result.length) {
         return null;
@@ -127,36 +149,44 @@ function _generateBoundingVolumesFromGeometry(convertedAttributesMap, geoidHeigh
  * @param params.tileContent - B3DM decoded content
  * @param params.nodeId - new node ID
  * @param params.featuresHashArray - hash array of features that is needed to not to mix up same features in parent and child nodes
- * @param params.attributesStorageInfo - attributes metadata from 3DSceneLayer json
+ * @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
  * @returns Array of I3S node resources
  */
-async function _makeNodeResources({ convertedAttributes, material, texture, tileContent, nodeId, featuresHashArray, attributeStorageInfo, draco, workerSource }) {
+async function _makeNodeResources({ convertedAttributes, material, texture, tileContent, nodeId, featuresHashArray, propertyTable, attributeStorageInfo, draco, workerSource }) {
     const boundingVolumes = convertedAttributes.boundingVolumes;
     const vertexCount = convertedAttributes.positions.length / VALUES_PER_VERTEX;
-    const { faceRange, featureIds, positions, normals, colors, texCoords, featureCount } = (0, geometry_attributes_1.generateAttributes)(convertedAttributes);
+    const { faceRange, featureIds, positions, normals, colors, uvRegions, texCoords, featureCount } = (0, geometry_attributes_1.generateAttributes)(convertedAttributes);
     if (tileContent.batchTableJson) {
         makeFeatureIdsUnique(featureIds, convertedAttributes.featureIndices, featuresHashArray, tileContent.batchTableJson);
     }
     const header = new Uint32Array(2);
     const typedFeatureIds = generateBigUint64Array(featureIds);
     header.set([vertexCount, featureCount], 0);
-    const fileBuffer = new Uint8Array((0, loader_utils_1.concatenateArrayBuffers)(header.buffer, positions.buffer, normals.buffer, texture ? texCoords.buffer : new ArrayBuffer(0), colors.buffer, typedFeatureIds.buffer, faceRange.buffer));
+    const fileBuffer = new Uint8Array((0, loader_utils_1.concatenateArrayBuffers)(header.buffer, positions.buffer, normals.buffer, texture ? texCoords.buffer : new ArrayBuffer(0), colors.buffer, uvRegions, typedFeatureIds.buffer, faceRange.buffer));
     const compressedGeometry = draco
         ? generateCompressedGeometry(vertexCount, convertedAttributes, {
             positions,
             normals,
             texCoords: texture ? texCoords : new Float32Array(0),
             colors,
+            uvRegions,
             featureIds,
             faceRange
         }, workerSource.draco)
         : null;
-    const attributes = convertBatchTableToAttributeBuffers(tileContent.batchTableJson, featureIds, attributeStorageInfo);
+    let attributes = [];
+    if (attributeStorageInfo && propertyTable) {
+        attributes = convertPropertyTableToAttributeBuffers(featureIds, propertyTable, attributeStorageInfo);
+    }
     return {
+        nodeId,
         geometry: fileBuffer,
         compressedGeometry,
         texture,
+        hasUvRegions: Boolean(uvRegions.length),
         sharedResources: getSharedResources(tileContent.gltf?.materials || [], nodeId),
         meshMaterial: material,
         vertexCount,
@@ -167,26 +197,32 @@ async function _makeNodeResources({ convertedAttributes, material, texture, tile
 }
 /**
  * Convert attributes from the gltf nodes tree to i3s plain geometry
- * @param tileContent - 3d tile content
+ * @param attributesData - geometry attributes from gltf
+ * @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
  * @returns map of converted geometry attributes
  */
-async function convertAttributes(attributesData, useCartesianPositions) {
-    const { gltfMaterials, nodes, cartographicOrigin, cartesianModelMatrix } = attributesData;
+async function convertAttributes(attributesData, materialAndTextureList, useCartesianPositions) {
+    const { nodes, images, cartographicOrigin, cartesianModelMatrix } = attributesData;
     const attributesMap = new Map();
-    for (const material of gltfMaterials || [{ id: 'default' }]) {
-        attributesMap.set(material.id, {
+    for (const materialAndTexture of materialAndTextureList) {
+        const attributes = {
             positions: new Float32Array(0),
             normals: new Float32Array(0),
             texCoords: new Float32Array(0),
             colors: new Uint8Array(0),
+            uvRegions: new Uint16Array(0),
             featureIndicesGroups: [],
             featureIndices: [],
-            boundingVolumes: null
-        });
+            boundingVolumes: null,
+            mergedMaterials: materialAndTexture.mergedMaterials
+        };
+        for (const mergedMaterial of materialAndTexture.mergedMaterials) {
+            attributesMap.set(mergedMaterial.originalMaterialId, attributes);
+        }
     }
-    convertNodes(nodes, cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions);
+    convertNodes(nodes, images, cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions);
     for (const attrKey of attributesMap.keys()) {
         const attributes = attributesMap.get(attrKey);
         if (!attributes) {
@@ -208,17 +244,19 @@ exports.convertAttributes = convertAttributes;
  * 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 tileContent - 3d tile content
+ * @param images - gltf images array
+ * @param cartographicOrigin - cartographic origin of bounding volume
+ * @param cartesianModelMatrix - cartesian model matrix to convert coordinates to cartographic
  * @param attributesMap - 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 matrix - transformation matrix - cumulative transformation matrix formed from all parent node matrices
  * @returns {void}
  */
-function convertNodes(nodes, cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions, matrix = new core_1.Matrix4([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1])) {
+function convertNodes(nodes, images, cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions, matrix = new core_1.Matrix4([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1])) {
     if (nodes) {
         for (const node of nodes) {
-            convertNode(node, cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions, matrix);
+            convertNode(node, images, cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions, matrix);
         }
     }
 }
@@ -248,25 +286,31 @@ function getCompositeTransformationMatrix(node, matrix) {
 /**
  * Convert all primitives of node and all children nodes
  * @param node - gltf node
- * @param {Object} tileContent - 3d tile content
+ * @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
  *   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
  */
-function convertNode(node, cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions, matrix = new core_1.Matrix4([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1])) {
+function convertNode(node, images, cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions, matrix = new core_1.Matrix4([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1])) {
     const transformationMatrix = getCompositeTransformationMatrix(node, matrix);
     const mesh = node.mesh;
     if (mesh) {
-        convertMesh(mesh, cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions, transformationMatrix);
+        convertMesh(mesh, images, cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions, transformationMatrix);
     }
-    convertNodes(node.children || [], cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions, transformationMatrix);
+    convertNodes(node.children || [], images, cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions, transformationMatrix);
 }
 /**
- * Convert all primitives of node and all children nodes
- * @param mesh - gltf node
- * @param content - 3d tile content
+ * Convert all primitives of the mesh
+ * @param mesh - gltf mesh data
+ * @param images - gltf images array
+ * @param cartographicOrigin - cartographic origin of bounding volume
+ * @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.
  * 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
@@ -274,11 +318,13 @@ function convertNode(node, cartographicOrigin, cartesianModelMatrix, attributesM
  
  * @param {Matrix4} matrix - transformation matrix - cumulative transformation matrix formed from all parent node matrices
  */
-function convertMesh(mesh, cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions = false, matrix = new core_1.Matrix4([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1])) {
+function convertMesh(mesh, images, cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions = false, matrix = new core_1.Matrix4([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1])) {
     for (const primitive of mesh.primitives) {
         let outputAttributes = null;
+        let materialUvRegion;
         if (primitive.material) {
-            outputAttributes = attributesMap.get(primitive.material.id);
+            outputAttributes = attributesMap.get(primitive.material.uniqueId);
+            materialUvRegion = outputAttributes?.mergedMaterials.find(({ originalMaterialId }) => originalMaterialId === primitive.material?.uniqueId)?.uvRegion;
         }
         else if (attributesMap.has('default')) {
             outputAttributes = attributesMap.get('default');
@@ -308,8 +354,11 @@ function convertMesh(mesh, cartographicOrigin, cartesianModelMatrix, attributesM
         }));
         outputAttributes.texCoords = (0, loader_utils_1.concatenateTypedArrays)(outputAttributes.texCoords, flattenTexCoords(attributes.TEXCOORD_0 && attributes.TEXCOORD_0.value, primitive.indices?.value));
         outputAttributes.colors = (0, loader_utils_1.concatenateTypedArrays)(outputAttributes.colors, flattenColors(attributes.COLOR_0, primitive.indices?.value));
+        if (materialUvRegion) {
+            outputAttributes.uvRegions = (0, loader_utils_1.concatenateTypedArrays)(outputAttributes.uvRegions, createUvRegion(materialUvRegion, primitive.indices?.value));
+        }
         outputAttributes.featureIndicesGroups = outputAttributes.featureIndicesGroups || [];
-        outputAttributes.featureIndicesGroups.push(flattenBatchIds(getBatchIdsByAttributeName(attributes), primitive.indices?.value));
+        outputAttributes.featureIndicesGroups.push(flattenBatchIds(getBatchIds(attributes, primitive, images), primitive.indices?.value));
     }
 }
 /**
@@ -428,6 +477,19 @@ function flattenColors(colorsAttribute, indices) {
     }
     return newColors;
 }
+/**
+ * Create per-vertex uv-region array
+ * @param materialUvRegion - uv-region fragment for a single vertex
+ * @param indices - geometry indices data
+ * @returns - uv-region array
+ */
+function createUvRegion(materialUvRegion, indices) {
+    const result = new Uint16Array(indices.length * 4);
+    for (let i = 0; i < result.length; i += 4) {
+        result.set(materialUvRegion, i);
+    }
+    return result;
+}
 /**
  * Flatten batchedIds list based on indices to right ordered array, compatible with i3s
  * @param batchedIds - gltf primitive
@@ -446,34 +508,123 @@ function flattenBatchIds(batchedIds, indices) {
     return newBatchIds;
 }
 /**
- * Return batchIds based on possible attribute names for different kind of maps.
- * @param attributes - the gltf primitive attributes
- * @returns batch ids attribute
+ * Get batchIds for featureIds creation
+ * @param attributes - gltf accessors
+ * @param primitive - gltf primitive data
+ * @param images - gltf texture images
  */
-function getBatchIdsByAttributeName(attributes) {
-    let batchIds = [];
+function getBatchIds(attributes, primitive, images) {
+    const batchIds = (0, batch_ids_extensions_1.handleBatchIdsExtensions)(attributes, primitive, images);
+    if (batchIds.length) {
+        return batchIds;
+    }
     for (let index = 0; index < BATCHED_ID_POSSIBLE_ATTRIBUTE_NAMES.length; index++) {
         const possibleBatchIdAttributeName = BATCHED_ID_POSSIBLE_ATTRIBUTE_NAMES[index];
         if (attributes[possibleBatchIdAttributeName] &&
             attributes[possibleBatchIdAttributeName].value) {
-            batchIds = attributes[possibleBatchIdAttributeName].value;
-            break;
+            return attributes[possibleBatchIdAttributeName].value;
         }
     }
-    return batchIds;
+    return [];
 }
 /**
  * Convert GLTF material to I3S material definitions and textures
  * @param sourceMaterials Source GLTF materials
+ * @param shouldMergeMaterials - if true - the converter will try to merge similar materials
+ *                               to be able to merge primitives having those materials
  * @returns Array of Couples I3SMaterialDefinition + texture content
  */
-function convertMaterials(sourceMaterials = []) {
-    const result = [];
+async function convertMaterials(sourceMaterials = [], shouldMergeMaterials) {
+    let materials = [];
     for (const sourceMaterial of sourceMaterials) {
-        result.push(convertMaterial(sourceMaterial));
+        materials.push(convertMaterial(sourceMaterial));
+    }
+    if (shouldMergeMaterials) {
+        materials = await mergeAllMaterials(materials);
+    }
+    return materials;
+}
+/**
+ * Merge materials when possible
+ * @param materials materials array
+ * @returns merged materials array
+ */
+async function mergeAllMaterials(materials) {
+    const result = [];
+    while (materials.length > 0) {
+        let newMaterial = materials.splice(0, 1)[0];
+        const mergedIndices = [];
+        for (let i = 0; i < materials.length; i++) {
+            const material = materials[i];
+            if ((newMaterial.texture && material.texture) ||
+                (!newMaterial.texture && !material.texture)) {
+                newMaterial = await mergeMaterials(newMaterial, material);
+                mergedIndices.push(i);
+            }
+        }
+        if (newMaterial.texture && mergedIndices.length) {
+            const newWidth = newMaterial.mergedMaterials?.reduce((accum, { textureSize }) => accum + (textureSize?.width || 0), 0);
+            const newHeight = newMaterial.mergedMaterials?.reduce((accum, { textureSize }) => Math.max(accum, textureSize?.height || 0), 0);
+            let currentX = -1;
+            for (const aTextureMetadata of newMaterial.mergedMaterials) {
+                if (aTextureMetadata.textureSize) {
+                    const newX = currentX +
+                        1 +
+                        (aTextureMetadata.textureSize.width / newWidth) *
+                            2 ** (Uint16Array.BYTES_PER_ELEMENT * 8) -
+                        1;
+                    aTextureMetadata.uvRegion = new Uint16Array([
+                        currentX + 1,
+                        0,
+                        newX,
+                        (aTextureMetadata.textureSize.height / newHeight) *
+                            2 ** (Uint16Array.BYTES_PER_ELEMENT * 8) -
+                            1
+                    ]);
+                    currentX = newX;
+                }
+            }
+            newMaterial.texture.image.width = newWidth;
+            newMaterial.texture.image.height = newHeight;
+        }
+        for (const index of mergedIndices.reverse()) {
+            materials.splice(index, 1);
+        }
+        result.push(newMaterial);
+    }
+    if (!result.length) {
+        result.push({
+            material: getDefaultMaterial(),
+            mergedMaterials: [{ originalMaterialId: 'default' }]
+        });
     }
     return result;
 }
+/**
+ * Merge 2 materials including texture
+ * @param material1
+ * @param material2
+ * @returns
+ */
+async function mergeMaterials(material1, material2) {
+    if (material1.texture?.bufferView &&
+        material2.texture?.bufferView &&
+        material1.mergedMaterials &&
+        material2.mergedMaterials) {
+        const buffer1 = Buffer.from(material1.texture.bufferView.data);
+        const buffer2 = Buffer.from(material2.texture.bufferView.data);
+        // @ts-ignore
+        const { joinImages } = await Promise.resolve().then(() => __importStar(require('join-images')));
+        const sharpData = await joinImages([buffer1, buffer2], { direction: 'horizontal' });
+        material1.texture.bufferView.data = await sharpData
+            .toFormat(material1.texture.mimeType === 'image/png' ? 'png' : 'jpeg')
+            .toBuffer();
+        // @ts-ignore
+        material1.material.pbrMetallicRoughness.baseColorTexture.textureSetDefinitionId = 1;
+    }
+    material1.mergedMaterials = material1.mergedMaterials.concat(material2.mergedMaterials);
+    return material1;
+}
 /**
  * Convert texture and material from gltf 2.0 material object
  * @param sourceMaterial - material object
@@ -505,6 +656,9 @@ function convertMaterial(sourceMaterial) {
             textureSetDefinitionId: 0
         };
     }
+    const uniqueId = (0, uuid_1.v4)();
+    sourceMaterial.uniqueId = uniqueId;
+    let mergedMaterials = [{ originalMaterialId: uniqueId }];
     if (!texture) {
         // Should use default baseColorFactor if it is not present in source material
         // https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#reference-pbrmetallicroughness
@@ -512,7 +666,10 @@ function convertMaterial(sourceMaterial) {
         material.pbrMetallicRoughness.baseColorFactor =
             (baseColorFactor && baseColorFactor.map((c) => Math.round(c * 255))) || undefined;
     }
-    return { material, texture };
+    else {
+        mergedMaterials[0].textureSize = { width: texture.image.width, height: texture.image.height };
+    }
+    return { material, texture, mergedMaterials };
 }
 /**
  * Converts from `alphaMode` material property from GLTF to I3S format
@@ -621,7 +778,9 @@ function extractSharedResourcesMaterialInfo(baseColorFactor, metallicFactor = 1)
     const specular = dielectricSpecular.lerp(dielectricSpecular, baseColorVector, metallicFactor);
     return {
         params: {
+            // @ts-expect-error NumericArray
             diffuse: diffuse.toArray(),
+            // @ts-expect-error NumericArray
             specular: specular.toArray(),
             renderMode: 'solid'
         }
@@ -648,7 +807,7 @@ function extractSharedResourcesTextureInfo(texture, nodeId) {
     };
 }
 /**
- * Formula for counting imageId:
+ * Formula for calculating imageId:
  * https://github.com/Esri/i3s-spec/blob/0a6366a9249b831db8436c322f8d27521e86cf07/format/Indexed%203d%20Scene%20Layer%20Format%20Specification.md#generating-image-ids
  * @param texture - texture image info
  * @param nodeId - I3S node ID
@@ -738,43 +897,53 @@ function replaceIndicesByUnique(indicesArray, featureMap) {
     }
 }
 /**
- * Convert batch table data to attribute buffers.
- * @param {Object} batchTable - table with metadata for particular feature.
+ * Convert property table data to attribute buffers.
  * @param {Array} featureIds
+ * @param {Object} propertyTable - table with metadata for particular feature.
  * @param {Array} attributeStorageInfo
  * @returns {Array} - Array of file buffers.
  */
-function convertBatchTableToAttributeBuffers(batchTable, featureIds, attributeStorageInfo) {
+function convertPropertyTableToAttributeBuffers(featureIds, propertyTable, attributeStorageInfo) {
     const attributeBuffers = [];
-    if (batchTable) {
-        const batchTableWithFeatureIds = {
-            OBJECTID: featureIds,
-            ...batchTable
-        };
-        for (const key in batchTableWithFeatureIds) {
-            const type = getAttributeType(key, attributeStorageInfo);
-            let attributeBuffer = null;
-            switch (type) {
-                case OBJECT_ID_TYPE:
-                case SHORT_INT_TYPE:
-                    attributeBuffer = generateShortIntegerAttributeBuffer(batchTableWithFeatureIds[key]);
-                    break;
-                case DOUBLE_TYPE:
-                    attributeBuffer = generateDoubleAttributeBuffer(batchTableWithFeatureIds[key]);
-                    break;
-                case STRING_TYPE:
-                    attributeBuffer = generateStringAttributeBuffer(batchTableWithFeatureIds[key]);
-                    break;
-                default:
-                    attributeBuffer = generateStringAttributeBuffer(batchTableWithFeatureIds[key]);
-            }
-            if (attributeBuffer) {
-                attributeBuffers.push(attributeBuffer);
-            }
-        }
+    const needFlattenPropertyTable = (0, feature_attributes_1.checkPropertiesLength)(featureIds, propertyTable);
+    const properties = needFlattenPropertyTable
+        ? (0, feature_attributes_1.flattenPropertyTableByFeatureIds)(featureIds, propertyTable)
+        : propertyTable;
+    const propertyTableWithObjectIds = {
+        OBJECTID: featureIds,
+        ...properties
+    };
+    for (const propertyName in propertyTableWithObjectIds) {
+        const type = getAttributeType(propertyName, attributeStorageInfo);
+        const value = propertyTableWithObjectIds[propertyName];
+        const attributeBuffer = generateAttributeBuffer(type, value);
+        attributeBuffers.push(attributeBuffer);
     }
     return attributeBuffers;
 }
+/**
+ * Generates attribute buffer based on attribute type
+ * @param type
+ * @param value
+ */
+function generateAttributeBuffer(type, value) {
+    let attributeBuffer;
+    switch (type) {
+        case OBJECT_ID_TYPE:
+        case SHORT_INT_TYPE:
+            attributeBuffer = generateShortIntegerAttributeBuffer(value);
+            break;
+        case DOUBLE_TYPE:
+            attributeBuffer = generateDoubleAttributeBuffer(value);
+            break;
+        case STRING_TYPE:
+            attributeBuffer = generateStringAttributeBuffer(value);
+            break;
+        default:
+            attributeBuffer = generateStringAttributeBuffer(value);
+    }
+    return attributeBuffer;
+}
 /**
  * Return attribute type.
  * @param {String} key
@@ -848,7 +1017,7 @@ function generateBigUint64Array(featureIds) {
  * @returns {Promise<object>} - COmpressed geometry.
  */
 async function generateCompressedGeometry(vertexCount, convertedAttributes, attributes, dracoWorkerSoure) {
-    const { positions, normals, texCoords, colors, featureIds, faceRange } = attributes;
+    const { positions, normals, texCoords, colors, uvRegions, featureIds, faceRange } = attributes;
     const indices = new Uint32Array(vertexCount);
     for (let index = 0; index < indices.length; index++) {
         indices.set([index], index);
@@ -870,6 +1039,12 @@ async function generateCompressedGeometry(vertexCount, convertedAttributes, attr
             'i3s-feature-ids': new Int32Array(featureIds)
         }
     };
+    if (uvRegions.length) {
+        compressedAttributes['uv-region'] = uvRegions;
+        attributesMetadata['uv-region'] = {
+            'i3s-attribute-type': 'uv-region'
+        };
+    }
     return (0, core_2.encode)({ attributes: compressedAttributes, indices }, draco_1.DracoWriterWorker, {
         ...draco_1.DracoWriterWorker.options,
         source: dracoWorkerSoure,
@@ -899,3 +1074,78 @@ function generateFeatureIndexAttribute(featureIndex, faceRange) {
     }
     return orderedFeatureIndices;
 }
+/**
+ * Find property table in tile
+ * For example it can be batchTable for b3dm files or property table in gLTF extension.
+ * @param sourceTile
+ * @return batch table from b3dm / feature properties from EXT_FEATURE_METADATA
+ */
+function getPropertyTable(tileContent) {
+    const batchTableJson = tileContent?.batchTableJson;
+    if (batchTableJson) {
+        return batchTableJson;
+    }
+    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_FEATURE_METADATA: {
+            return getPropertyTableFromExtFeatureMetadata(extension);
+        }
+        default:
+            return null;
+    }
+}
+exports.getPropertyTable = getPropertyTable;
+/**
+ * Check extensions which can be with property table inside.
+ * @param sourceTile
+ */
+function getPropertyTableExtension(tileContent) {
+    const extensionsWithPropertyTables = [EXT_FEATURE_METADATA, EXT_MESH_FEATURES];
+    const extensionsUsed = tileContent?.gltf?.extensionsUsed;
+    if (!extensionsUsed) {
+        return { extensionName: null, extension: null };
+    }
+    let extensionName = '';
+    for (const extensionItem of tileContent?.gltf?.extensionsUsed || []) {
+        if (extensionsWithPropertyTables.includes(extensionItem)) {
+            extensionName = extensionItem;
+            break;
+        }
+    }
+    const extension = tileContent?.gltf?.extensions?.[extensionName];
+    return { extensionName, extension };
+}
+/**
+ * Handle EXT_feature_metadata to get property table
+ * @param extension
+ * TODO add EXT_feature_metadata feature textures support.
+ */
+function getPropertyTableFromExtFeatureMetadata(extension) {
+    if (extension?.featureTextures) {
+        console.warn('The I3S converter does not yet support the EXT_feature_metadata feature textures');
+        return 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;
+        }
+    }
+    console.warn("The I3S converter couldn't handle EXT_feature_metadata extension");
+    return null;
+}