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

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

@@ -4,6 +4,7 @@ import { DracoWriterWorker } from '@loaders.gl/draco';
 import { assert, encode } from '@loaders.gl/core';
 import { concatenateArrayBuffers, concatenateTypedArrays } from '@loaders.gl/loader-utils';
 import md5 from 'md5';
+import { v4 as uuidv4 } from 'uuid';
 import { generateAttributes } from './geometry-attributes';
 import { createBoundingVolumesFromGeometry } from './coordinate-converter';
 import { prepareDataForAttributesConversion } from './gltf-attributes';
@@ -24,47 +25,32 @@ const EXT_FEATURE_METADATA = 'EXT_feature_metadata';
 const EXT_MESH_FEATURES = 'EXT_mesh_features';
 let scratchVector = new Vector3();
 
-export default async function convertB3dmToI3sGeometry(tileContent, addNodeToNodePage, propertyTable, featuresHashArray, attributeStorageInfo, draco, generateBoundingVolumes, geoidHeightModel, workerSource) {
+export default async function convertB3dmToI3sGeometry(tileContent, addNodeToNodePage, propertyTable, featuresHashArray, attributeStorageInfo, draco, generateBoundingVolumes, shouldMergeMaterials, geoidHeightModel, workerSource) {
   var _tileContent$gltf;
   const useCartesianPositions = generateBoundingVolumes;
-  const materialAndTextureList = convertMaterials((_tileContent$gltf = tileContent.gltf) === null || _tileContent$gltf === void 0 ? void 0 : _tileContent$gltf.materials);
+  const materialAndTextureList = await convertMaterials((_tileContent$gltf = tileContent.gltf) === null || _tileContent$gltf === void 0 ? void 0 : _tileContent$gltf.materials, shouldMergeMaterials);
   const dataForAttributesConversion = prepareDataForAttributesConversion(tileContent);
-  const convertedAttributesMap = await convertAttributes(dataForAttributesConversion, useCartesianPositions);
+  const convertedAttributesMap = await convertAttributes(dataForAttributesConversion, materialAndTextureList, useCartesianPositions);
 
   if (generateBoundingVolumes) {
     _generateBoundingVolumesFromGeometry(convertedAttributesMap, geoidHeightModel);
   }
-  if (convertedAttributesMap.has('default')) {
-    materialAndTextureList.push({
-      material: getDefaultMaterial()
-    });
-  }
   const result = [];
-  let {
-    materials = []
-  } = tileContent.gltf || {
-    materials: []
-  };
-  if (!(materials !== null && materials !== void 0 && 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;
     }
 
-    const convertedAttributes = convertedAttributesMap.get(sourceMaterial.id);
+    const convertedAttributes = convertedAttributesMap.get(originarMaterialId);
     if (!convertedAttributes) {
       continue;
     }
     const {
       material,
       texture
-    } = materialAndTextureList[i];
-    const nodeId = addNodeToNodePage();
+    } = materialAndTexture;
+    const nodeId = await addNodeToNodePage();
     result.push(await _makeNodeResources({
       convertedAttributes,
       material,
@@ -121,6 +107,7 @@ async function _makeNodeResources(_ref) {
     positions,
     normals,
     colors,
+    uvRegions,
     texCoords,
     featureCount
   } = generateAttributes(convertedAttributes);
@@ -130,12 +117,13 @@ async function _makeNodeResources(_ref) {
   const header = new Uint32Array(2);
   const typedFeatureIds = generateBigUint64Array(featureIds);
   header.set([vertexCount, featureCount], 0);
-  const fileBuffer = new Uint8Array(concatenateArrayBuffers(header.buffer, positions.buffer, normals.buffer, texture ? texCoords.buffer : new ArrayBuffer(0), colors.buffer, typedFeatureIds.buffer, faceRange.buffer));
+  const fileBuffer = new Uint8Array(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;
@@ -148,6 +136,7 @@ async function _makeNodeResources(_ref) {
     geometry: fileBuffer,
     compressedGeometry,
     texture,
+    hasUvRegions: Boolean(uvRegions.length),
     sharedResources: getSharedResources(((_tileContent$gltf2 = tileContent.gltf) === null || _tileContent$gltf2 === void 0 ? void 0 : _tileContent$gltf2.materials) || [], nodeId),
     meshMaterial: material,
     vertexCount,
@@ -157,27 +146,29 @@ async function _makeNodeResources(_ref) {
   };
 }
 
-export async function convertAttributes(attributesData, useCartesianPositions) {
+export async function convertAttributes(attributesData, materialAndTextureList, useCartesianPositions) {
   const {
-    gltfMaterials,
     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()) {
@@ -244,10 +235,19 @@ function convertMesh(mesh, images, cartographicOrigin, cartesianModelMatrix, att
   let useCartesianPositions = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : false;
   let matrix = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : new Matrix4([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
   for (const primitive of mesh.primitives) {
-    var _primitive$indices, _primitive$indices2, _primitive$indices3, _primitive$indices4, _primitive$indices5;
+    var _primitive$indices, _primitive$indices2, _primitive$indices3, _primitive$indices4, _primitive$indices6;
     let outputAttributes = null;
+    let materialUvRegion;
     if (primitive.material) {
-      outputAttributes = attributesMap.get(primitive.material.id);
+      var _outputAttributes, _outputAttributes$mer;
+      outputAttributes = attributesMap.get(primitive.material.uniqueId);
+      materialUvRegion = (_outputAttributes = outputAttributes) === null || _outputAttributes === void 0 ? void 0 : (_outputAttributes$mer = _outputAttributes.mergedMaterials.find(_ref2 => {
+        var _primitive$material;
+        let {
+          originalMaterialId
+        } = _ref2;
+        return originalMaterialId === ((_primitive$material = primitive.material) === null || _primitive$material === void 0 ? void 0 : _primitive$material.uniqueId);
+      })) === null || _outputAttributes$mer === void 0 ? void 0 : _outputAttributes$mer.uvRegion;
     } else if (attributesMap.has('default')) {
       outputAttributes = attributesMap.get('default');
     }
@@ -276,8 +276,12 @@ function convertMesh(mesh, images, cartographicOrigin, cartesianModelMatrix, att
     }));
     outputAttributes.texCoords = concatenateTypedArrays(outputAttributes.texCoords, flattenTexCoords(attributes.TEXCOORD_0 && attributes.TEXCOORD_0.value, (_primitive$indices3 = primitive.indices) === null || _primitive$indices3 === void 0 ? void 0 : _primitive$indices3.value));
     outputAttributes.colors = concatenateTypedArrays(outputAttributes.colors, flattenColors(attributes.COLOR_0, (_primitive$indices4 = primitive.indices) === null || _primitive$indices4 === void 0 ? void 0 : _primitive$indices4.value));
+    if (materialUvRegion) {
+      var _primitive$indices5;
+      outputAttributes.uvRegions = concatenateTypedArrays(outputAttributes.uvRegions, createUvRegion(materialUvRegion, (_primitive$indices5 = primitive.indices) === null || _primitive$indices5 === void 0 ? void 0 : _primitive$indices5.value));
+    }
     outputAttributes.featureIndicesGroups = outputAttributes.featureIndicesGroups || [];
-    outputAttributes.featureIndicesGroups.push(flattenBatchIds(getBatchIds(attributes, primitive, images), (_primitive$indices5 = primitive.indices) === null || _primitive$indices5 === void 0 ? void 0 : _primitive$indices5.value));
+    outputAttributes.featureIndicesGroups.push(flattenBatchIds(getBatchIds(attributes, primitive, images), (_primitive$indices6 = primitive.indices) === null || _primitive$indices6 === void 0 ? void 0 : _primitive$indices6.value));
   }
 }
 
@@ -369,6 +373,14 @@ function flattenColors(colorsAttribute, indices) {
   return newColors;
 }
 
+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;
+}
+
 function flattenBatchIds(batchedIds, indices) {
   if (!batchedIds.length || !indices.length) {
     return [];
@@ -395,15 +407,95 @@ function getBatchIds(attributes, primitive, images) {
   return [];
 }
 
-function convertMaterials() {
+async function convertMaterials() {
   let sourceMaterials = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
-  const result = [];
+  let shouldMergeMaterials = arguments.length > 1 ? arguments[1] : undefined;
+  let materials = [];
   for (const sourceMaterial of sourceMaterials) {
-    result.push(convertMaterial(sourceMaterial));
+    materials.push(convertMaterial(sourceMaterial));
+  }
+  if (shouldMergeMaterials) {
+    materials = await mergeAllMaterials(materials);
+  }
+  return materials;
+}
+
+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) {
+      var _newMaterial$mergedMa, _newMaterial$mergedMa2;
+      const newWidth = (_newMaterial$mergedMa = newMaterial.mergedMaterials) === null || _newMaterial$mergedMa === void 0 ? void 0 : _newMaterial$mergedMa.reduce((accum, _ref3) => {
+        let {
+          textureSize
+        } = _ref3;
+        return accum + ((textureSize === null || textureSize === void 0 ? void 0 : textureSize.width) || 0);
+      }, 0);
+      const newHeight = (_newMaterial$mergedMa2 = newMaterial.mergedMaterials) === null || _newMaterial$mergedMa2 === void 0 ? void 0 : _newMaterial$mergedMa2.reduce((accum, _ref4) => {
+        let {
+          textureSize
+        } = _ref4;
+        return Math.max(accum, (textureSize === null || textureSize === void 0 ? void 0 : 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;
 }
 
+async function mergeMaterials(material1, material2) {
+  var _material1$texture, _material2$texture;
+  if ((_material1$texture = material1.texture) !== null && _material1$texture !== void 0 && _material1$texture.bufferView && (_material2$texture = material2.texture) !== null && _material2$texture !== void 0 && _material2$texture.bufferView && material1.mergedMaterials && material2.mergedMaterials) {
+    const buffer1 = Buffer.from(material1.texture.bufferView.data);
+    const buffer2 = Buffer.from(material2.texture.bufferView.data);
+    try {
+      const {
+        joinImages
+      } = await import('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;
+    }
+    material1.material.pbrMetallicRoughness.baseColorTexture.textureSetDefinitionId = 1;
+  }
+  material1.mergedMaterials = material1.mergedMaterials.concat(material2.mergedMaterials);
+  return material1;
+}
+
 function convertMaterial(sourceMaterial) {
   var _sourceMaterial$emiss, _sourceMaterial$pbrMe, _sourceMaterial$pbrMe2, _sourceMaterial$pbrMe3;
   const material = {
@@ -427,14 +519,25 @@ function convertMaterial(sourceMaterial) {
       textureSetDefinitionId: 0
     };
   }
+  const uniqueId = uuidv4();
+  sourceMaterial.uniqueId = uniqueId;
+  let mergedMaterials = [{
+    originalMaterialId: uniqueId
+  }];
   if (!texture) {
     var _sourceMaterial$pbrMe4;
     const baseColorFactor = sourceMaterial === null || sourceMaterial === void 0 ? void 0 : (_sourceMaterial$pbrMe4 = sourceMaterial.pbrMetallicRoughness) === null || _sourceMaterial$pbrMe4 === void 0 ? void 0 : _sourceMaterial$pbrMe4.baseColorFactor;
     material.pbrMetallicRoughness.baseColorFactor = baseColorFactor && baseColorFactor.map(c => Math.round(c * 255)) || undefined;
+  } else {
+    mergedMaterials[0].textureSize = {
+      width: texture.image.width,
+      height: texture.image.height
+    };
   }
   return {
     material,
-    texture
+    texture,
+    mergedMaterials
   };
 }
 
@@ -679,6 +782,7 @@ async function generateCompressedGeometry(vertexCount, convertedAttributes, attr
     normals,
     texCoords,
     colors,
+    uvRegions,
     featureIds,
     faceRange
   } = attributes;
@@ -703,6 +807,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 encode({
     attributes: compressedAttributes,
     indices