@loaders.gl/tile-converter 3.3.0-alpha.8 → 3.3.0

package/dist/i3s-converter/helpers/batch-ids-extensions.d.ts

@@ -1,9 +1,9 @@
 import { GLTFAccessorPostprocessed, GLTFImagePostprocessed, GLTFMeshPrimitivePostprocessed } from '@loaders.gl/gltf';
 /**
  * Getting batchIds from 3DTilesNext extensions.
- * @param attributes
- * @param primitive
- * @param textures
+ * @param attributes - gltf accessors
+ * @param primitive - gltf primitive data
+ * @param images - gltf texture images
  */
 export declare function handleBatchIdsExtensions(attributes: {
     [key: string]: GLTFAccessorPostprocessed;

package/dist/i3s-converter/helpers/batch-ids-extensions.js

@@ -5,9 +5,9 @@ const EXT_MESH_FEATURES = 'EXT_mesh_features';
 const EXT_FEATURE_METADATA = 'EXT_feature_metadata';
 /**
  * Getting batchIds from 3DTilesNext extensions.
- * @param attributes
- * @param primitive
- * @param textures
+ * @param attributes - gltf accessors
+ * @param primitive - gltf primitive data
+ * @param images - gltf texture images
  */
 function handleBatchIdsExtensions(attributes, primitive, images) {
     const extensions = primitive?.extensions;

package/dist/i3s-converter/helpers/geometry-attributes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geometry-attributes.d.ts","sourceRoot":"","sources":["../../../src/i3s-converter/helpers/geometry-attributes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,kBAAkB,EAAE,mBAAmB,EAA+B,MAAM,UAAU,CAAC;AAMpG;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,mBAAmB,GAAG,kBAAkB,CAwBtF"}
+{"version":3,"file":"geometry-attributes.d.ts","sourceRoot":"","sources":["../../../src/i3s-converter/helpers/geometry-attributes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,kBAAkB,EAAE,mBAAmB,EAA+B,MAAM,UAAU,CAAC;AAMpG;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,mBAAmB,GAAG,kBAAkB,CAyBtF"}

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

@@ -10,7 +10,7 @@ const POSITIONS_AND_NORMALS_PER_TRIANGLE = 9;
  * @returns attirbutes with featureCount, featureIds and changed faceRange.
  */
 function generateAttributes(attributes) {
-    const { positions, normals, texCoords, colors, featureIndices } = attributes;
+    const { positions, normals, texCoords, colors, uvRegions, featureIndices } = attributes;
     const triangleCount = positions.length / POSITIONS_AND_NORMALS_PER_TRIANGLE;
     if (!featureIndices.length) {
         return {
@@ -20,7 +20,8 @@ function generateAttributes(attributes) {
             positions,
             normals,
             texCoords,
-            colors
+            colors,
+            uvRegions
         };
     }
     const data = calculateFaceRangesAndFeaturesCount(featureIndices);
@@ -87,32 +88,34 @@ function getFrequentValue(values) {
  * @returns sorted list of attribute objects.
  */
 function makeAttributeObjects(attributes) {
-    const { featureIds, positions, normals, colors, texCoords, faceRange = new Uint32Array(0) } = attributes;
+    const { featureIds, positions, normals, colors, uvRegions, texCoords, faceRange = new Uint32Array(0) } = attributes;
     const groupedData = [];
     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({
             featureId: featureIds[index],
             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);
 }
@@ -124,7 +127,7 @@ function makeAttributeObjects(attributes) {
  * @returns sliced count
  */
 function getSliceAttributeCount(attributeName, startIndex, endIndex) {
-    const colorsPerVertex = 4;
+    const itemsPerVertex4 = 4;
     const texCoordsPerVertex = 2;
     const trianglesCount = endIndex - startIndex + 1;
     const vertexCount = trianglesCount * 3;
@@ -133,7 +136,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:
@@ -173,6 +177,7 @@ function groupAttributesAndRangesByFeatureId(unifiedObjects, featureCount) {
     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];
     let objIndex = 0;
@@ -183,6 +188,7 @@ function groupAttributesAndRangesByFeatureId(unifiedObjects, featureCount) {
         positions = (0, loader_utils_1.concatenateTypedArrays)(positions, currentAttributesObject.positions);
         normals = (0, loader_utils_1.concatenateTypedArrays)(normals, currentAttributesObject.normals);
         colors = (0, loader_utils_1.concatenateTypedArrays)(colors, currentAttributesObject.colors);
+        uvRegions = (0, loader_utils_1.concatenateTypedArrays)(uvRegions, currentAttributesObject.uvRegions);
         texCoords = (0, loader_utils_1.concatenateTypedArrays)(texCoords, currentAttributesObject.texCoords);
         const groupedObject = unifiedObjects[objIndex];
         range.push(groupedObject.positions.length / POSITIONS_AND_NORMALS_PER_TRIANGLE - 1 + sum);
@@ -192,5 +198,5 @@ function groupAttributesAndRangesByFeatureId(unifiedObjects, featureCount) {
     }
     range.push(positions.length / POSITIONS_AND_NORMALS_PER_TRIANGLE - 1);
     const faceRange = new Uint32Array(range);
-    return { faceRange, featureIds, positions, normals, colors, texCoords, featureCount };
+    return { faceRange, featureIds, positions, normals, colors, uvRegions, texCoords, featureCount };
 }

package/dist/i3s-converter/helpers/geometry-converter.d.ts

@@ -1,5 +1,5 @@
 import type { B3DMContent, FeatureTableJson } from '@loaders.gl/3d-tiles';
-import { ConvertedAttributes, I3SConvertedResources } from '../types';
+import { ConvertedAttributes, I3SConvertedResources, I3SMaterialWithTexture } from '../types';
 import { AttributeStorageInfo } from '@loaders.gl/i3s';
 import { Geoid } from '@math.gl/geoid';
 /** Usage of worker here brings more overhead than advantage */
@@ -9,24 +9,28 @@ import { B3DMAttributesData } from '../../i3s-attributes-worker';
  *
  * @param tileContent - 3d tile content
  * @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
  */
-export default function convertB3dmToI3sGeometry(tileContent: B3DMContent, addNodeToNodePage: () => number, propertyTable: FeatureTableJson | null, featuresHashArray: string[], attributeStorageInfo: AttributeStorageInfo[] | undefined, draco: boolean, generateBoundingVolumes: boolean, geoidHeightModel: Geoid, workerSource: {
+export default function convertB3dmToI3sGeometry(tileContent: B3DMContent, addNodeToNodePage: () => Promise<number>, propertyTable: FeatureTableJson | null, featuresHashArray: string[], attributeStorageInfo: AttributeStorageInfo[] | undefined, draco: boolean, generateBoundingVolumes: boolean, shouldMergeMaterials: boolean, geoidHeightModel: Geoid, workerSource: {
     [key: string]: string;
 }): Promise<I3SConvertedResources[] | null>;
 /**
  * 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
  */
-export declare function convertAttributes(attributesData: B3DMAttributesData, useCartesianPositions: boolean): Promise<Map<string, ConvertedAttributes>>;
+export declare function convertAttributes(attributesData: B3DMAttributesData, materialAndTextureList: I3SMaterialWithTexture[], useCartesianPositions: boolean): Promise<Map<string, ConvertedAttributes>>;
 /**
  * Find property table in tile
  * For example it can be batchTable for b3dm files or property table in gLTF extension.

package/dist/i3s-converter/helpers/geometry-converter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geometry-converter.d.ts","sourceRoot":"","sources":["../../../src/i3s-converter/helpers/geometry-converter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,WAAW,EAAE,gBAAgB,EAAC,MAAM,sBAAsB,CAAC;AAqBxE,OAAO,EACL,mBAAmB,EACnB,qBAAqB,EAGtB,MAAM,UAAU,CAAC;AAClB,OAAO,EACL,oBAAoB,EAIrB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAC,KAAK,EAAC,MAAM,gBAAgB,CAAC;AACrC,+DAA+D;AAC/D,OAAO,EAAC,kBAAkB,EAAsC,MAAM,6BAA6B,CAAC;AA6BpG;;;;;;;;;;;GAWG;AACH,wBAA8B,wBAAwB,CACpD,WAAW,EAAE,WAAW,EACxB,iBAAiB,EAAE,MAAM,MAAM,EAC/B,aAAa,EAAE,gBAAgB,GAAG,IAAI,EACtC,iBAAiB,EAAE,MAAM,EAAE,EAC3B,oBAAoB,EAAE,oBAAoB,EAAE,GAAG,SAAS,EACxD,KAAK,EAAE,OAAO,EACd,uBAAuB,EAAE,OAAO,EAChC,gBAAgB,EAAE,KAAK,EACvB,YAAY,EAAE;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;CAAC,GACpC,OAAO,CAAC,qBAAqB,EAAE,GAAG,IAAI,CAAC,CAmEzC;AAwID;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CACrC,cAAc,EAAE,kBAAkB,EAClC,qBAAqB,EAAE,OAAO,GAC7B,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC,CA2C3C;AA87BD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,WAAW,EAAE,WAAW,GAAG,gBAAgB,GAAG,IAAI,CAoBlF"}
+{"version":3,"file":"geometry-converter.d.ts","sourceRoot":"","sources":["../../../src/i3s-converter/helpers/geometry-converter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,WAAW,EAAE,gBAAgB,EAAC,MAAM,sBAAsB,CAAC;AAsBxE,OAAO,EACL,mBAAmB,EACnB,qBAAqB,EACrB,sBAAsB,EAGvB,MAAM,UAAU,CAAC;AAClB,OAAO,EACL,oBAAoB,EAIrB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAC,KAAK,EAAC,MAAM,gBAAgB,CAAC;AACrC,+DAA+D;AAC/D,OAAO,EAAC,kBAAkB,EAAsC,MAAM,6BAA6B,CAAC;AA6BpG;;;;;;;;;;;;;;GAcG;AACH,wBAA8B,wBAAwB,CACpD,WAAW,EAAE,WAAW,EACxB,iBAAiB,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,EACxC,aAAa,EAAE,gBAAgB,GAAG,IAAI,EACtC,iBAAiB,EAAE,MAAM,EAAE,EAC3B,oBAAoB,EAAE,oBAAoB,EAAE,GAAG,SAAS,EACxD,KAAK,EAAE,OAAO,EACd,uBAAuB,EAAE,OAAO,EAChC,oBAAoB,EAAE,OAAO,EAC7B,gBAAgB,EAAE,KAAK,EACvB,YAAY,EAAE;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;CAAC,GACpC,OAAO,CAAC,qBAAqB,EAAE,GAAG,IAAI,CAAC,CA0DzC;AA6ID;;;;;;;GAOG;AACH,wBAAsB,iBAAiB,CACrC,cAAc,EAAE,kBAAkB,EAClC,sBAAsB,EAAE,sBAAsB,EAAE,EAChD,qBAAqB,EAAE,OAAO,GAC7B,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC,CAgD3C;AA8lCD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,WAAW,EAAE,WAAW,GAAG,gBAAgB,GAAG,IAAI,CAoBlF"}

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

@@ -1,4 +1,27 @@
 "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 };
 };
@@ -10,6 +33,7 @@ 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");
@@ -39,18 +63,21 @@ let scratchVector = new core_1.Vector3();
  *
  * @param tileContent - 3d tile content
  * @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, addNodeToNodePage, propertyTable, 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);
+    const convertedAttributesMap = await convertAttributes(dataForAttributesConversion, materialAndTextureList, useCartesianPositions);
     /** Usage of worker here brings more overhead than advantage */
     // const convertedAttributesMap: Map<string, ConvertedAttributes> =
     //   await transformI3SAttributesOnWorker(dataForAttributesConversion, {
@@ -62,27 +89,18 @@ async function convertB3dmToI3sGeometry(tileContent, addNodeToNodePage, property
     if (generateBoundingVolumes) {
         _generateBoundingVolumesFromGeometry(convertedAttributesMap, geoidHeightModel);
     }
-    if (convertedAttributesMap.has('default')) {
-        materialAndTextureList.push({
-            material: getDefaultMaterial()
-        });
-    }
     const result = [];
-    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 nodeId = addNodeToNodePage();
+        const { material, texture } = materialAndTexture;
+        const nodeId = await addNodeToNodePage();
         result.push(await _makeNodeResources({
             convertedAttributes,
             material,
@@ -131,27 +149,30 @@ 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, 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)
@@ -165,6 +186,7 @@ async function _makeNodeResources({ convertedAttributes, material, texture, tile
         geometry: fileBuffer,
         compressedGeometry,
         texture,
+        hasUvRegions: Boolean(uvRegions.length),
         sharedResources: getSharedResources(tileContent.gltf?.materials || [], nodeId),
         meshMaterial: material,
         vertexCount,
@@ -175,24 +197,30 @@ 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, images, 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, images, cartographicOrigin, cartesianModelMatrix, attributesMap, useCartesianPositions);
     for (const attrKey of attributesMap.keys()) {
@@ -217,7 +245,8 @@ exports.convertAttributes = convertAttributes;
  *   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
- * @param tileContent - 3d tile content
+ * @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
@@ -258,7 +287,8 @@ function getCompositeTransformationMatrix(node, matrix) {
  * Convert all primitives of node and all children nodes
  * @param node - gltf node
  * @param images - gltf images array
- * @param {Object} tileContent - 3d tile content
+ * @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.
@@ -274,9 +304,13 @@ function convertNode(node, images, cartographicOrigin, cartesianModelMatrix, att
     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
@@ -287,8 +321,10 @@ function convertNode(node, images, cartographicOrigin, cartesianModelMatrix, att
 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');
@@ -318,6 +354,9 @@ function convertMesh(mesh, images, cartographicOrigin, cartesianModelMatrix, att
         }));
         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(getBatchIds(attributes, primitive, images), primitive.indices?.value));
     }
@@ -438,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
@@ -457,9 +509,9 @@ function flattenBatchIds(batchedIds, indices) {
 }
 /**
  * Get batchIds for featureIds creation
- * @param attributes
- * @param primitive
- * @param textures
+ * @param attributes - gltf accessors
+ * @param primitive - gltf primitive data
+ * @param images - gltf texture images
  */
 function getBatchIds(attributes, primitive, images) {
     const batchIds = (0, batch_ids_extensions_1.handleBatchIdsExtensions)(attributes, primitive, images);
@@ -478,15 +530,107 @@ function getBatchIds(attributes, primitive, images) {
 /**
  * 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);
+        try {
+            // @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();
+        }
+        catch (error) {
+            console.log('Join images into a texture atlas has failed. Consider usage `--split-nodes` option. (See documentation https://loaders.gl/modules/tile-converter/docs/cli-reference/tile-converter)');
+            throw error;
+        }
+        // @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
@@ -518,6 +662,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
@@ -525,7 +672,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
@@ -663,7 +813,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
@@ -754,8 +904,8 @@ function replaceIndicesByUnique(indicesArray, featureMap) {
 }
 /**
  * Convert property table data to attribute buffers.
- * @param {Object} propertyTable - table with metadata for particular feature.
  * @param {Array} featureIds
+ * @param {Object} propertyTable - table with metadata for particular feature.
  * @param {Array} attributeStorageInfo
  * @returns {Array} - Array of file buffers.
  */
@@ -873,7 +1023,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);
@@ -895,6 +1045,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,

package/dist/i3s-converter/helpers/gltf-attributes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gltf-attributes.d.ts","sourceRoot":"","sources":["../../../src/i3s-converter/helpers/gltf-attributes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,sBAAsB,CAAC;AAEtD,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,6BAA6B,CAAC;AAsBpE;;;;GAIG;AACH,wBAAgB,kCAAkC,CAAC,WAAW,EAAE,WAAW,GAAG,kBAAkB,CA2C/F"}
+{"version":3,"file":"gltf-attributes.d.ts","sourceRoot":"","sources":["../../../src/i3s-converter/helpers/gltf-attributes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,sBAAsB,CAAC;AAEtD,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,6BAA6B,CAAC;AAsBpE;;;;GAIG;AACH,wBAAgB,kCAAkC,CAAC,WAAW,EAAE,WAAW,GAAG,kBAAkB,CAyC/F"}

package/dist/i3s-converter/helpers/gltf-attributes.js

@@ -20,7 +20,6 @@ function getB3DMAttributesWithoutBufferView(attributes) {
  * @returns
  */
 function prepareDataForAttributesConversion(tileContent) {
-    const gltfMaterials = tileContent.gltf?.materials?.map((material) => ({ id: material.id }));
     let nodes = tileContent.gltf?.scene?.nodes ||
         tileContent.gltf?.scenes?.[0]?.nodes ||
         tileContent.gltf?.nodes ||
@@ -51,7 +50,6 @@ function prepareDataForAttributesConversion(tileContent) {
     const cartographicOrigin = tileContent.cartographicOrigin;
     const cartesianModelMatrix = tileContent.cartesianModelMatrix;
     return {
-        gltfMaterials,
         nodes,
         images,
         cartographicOrigin,
@@ -76,7 +74,8 @@ function prepareNodes(nodes) {
                         indices: { value: primitive?.indices?.value },
                         attributes: getB3DMAttributesWithoutBufferView(primitive.attributes),
                         material: {
-                            id: primitive?.material?.id
+                            id: primitive?.material?.id,
+                            uniqueId: primitive?.material?.uniqueId
                         }
                     }))
                 }