@loaders.gl/tile-converter 3.3.0-alpha.1 → 3.3.0-alpha.11

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

@@ -1,7 +1,5 @@
 import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-
 var _process$env;
-
 import { load, encode, fetchFile, getLoaderOptions, isBrowser } from '@loaders.gl/core';
 import { Tileset3D } from '@loaders.gl/tiles';
 import { CesiumIonLoader, Tiles3DLoader } from '@loaders.gl/3d-tiles';
@@ -11,16 +9,17 @@ import process from 'process';
 import transform from 'json-map-transform';
 import md5 from 'md5';
 import NodePages from './helpers/node-pages';
-import { writeFile, removeDir, writeFileForSlpk } from '../lib/utils/file-utils';
-import { compressWithChildProcess } from '../lib/utils/compress-util';
+import { writeFile, removeDir, writeFileForSlpk, removeFile } from '../lib/utils/file-utils';
+import { compressFileWithGzip, compressWithChildProcess
+} from '../lib/utils/compress-util';
 import { calculateFilesSize, timeConverter } from '../lib/utils/statistic-utills';
-import convertB3dmToI3sGeometry from './helpers/geometry-converter';
+import convertB3dmToI3sGeometry, { getPropertyTable } from './helpers/geometry-converter';
 import { createBoundingVolumes, convertBoundingVolumeToI3SFullExtent } from './helpers/coordinate-converter';
 import { createSceneServerPath } from './helpers/create-scene-server-path';
 import { convertGeometricErrorToScreenThreshold } from '../lib/utils/lod-conversion-utils';
 import { PGMLoader } from '../pgm-loader';
 import { LAYERS as layersTemplate } from './json-templates/layers';
-import { NODE as nodeTemplate } from './json-templates/node';
+import { GEOMETRY_DEFINITION as geometryDefinitionTemlate } from './json-templates/geometry-definitions';
 import { SHARED_RESOURCES as sharedResourcesTemplate } from './json-templates/shared-resources';
 import { validateNodeBoundingVolumes } from './helpers/node-debug';
 import { KTX2BasisWriterWorker } from '@loaders.gl/textures';
@@ -30,65 +29,49 @@ import { DracoWriterWorker } from '@loaders.gl/draco';
 import WriteQueue from '../lib/utils/write-queue';
 import { I3SAttributesWorker } from '../i3s-attributes-worker';
 import { BROWSER_ERROR_MESSAGE } from '../constants';
-const ION_DEFAULT_TOKEN = ((_process$env = process.env) === null || _process$env === void 0 ? void 0 : _process$env.IonToken) || 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiJlYWMxMzcyYy0zZjJkLTQwODctODNlNi01MDRkZmMzMjIxOWIiLCJpZCI6OTYyMCwic2NvcGVzIjpbImFzbCIsImFzciIsImdjIl0sImlhdCI6MTU2Mjg2NjI3M30.1FNiClUyk00YH_nWfSGpiQAjR5V2OvREDq1PJ5QMjWQ';
+import { createdStorageAttribute, createFieldAttribute, createPopupInfo, getAttributeType, getFieldAttributeType } from './helpers/feature-attributes';
+import { NodeIndexDocument } from './helpers/node-index-document';
+const ION_DEFAULT_TOKEN = ((_process$env = process.env) === null || _process$env === void 0 ? void 0 : _process$env.IonToken) ||
+'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiJlYWMxMzcyYy0zZjJkLTQwODctODNlNi01MDRkZmMzMjIxOWIiLCJpZCI6OTYyMCwic2NvcGVzIjpbImFzbCIsImFzciIsImdjIl0sImlhdCI6MTU2Mjg2NjI3M30.1FNiClUyk00YH_nWfSGpiQAjR5V2OvREDq1PJ5QMjWQ';
 const HARDCODED_NODES_PER_PAGE = 64;
 const _3D_TILES = '3DTILES';
 const _3D_OBJECT_LAYER_TYPE = '3DObject';
-const STRING_TYPE = 'string';
-const SHORT_INT_TYPE = 'Int32';
-const DOUBLE_TYPE = 'double';
-const OBJECT_ID_TYPE = 'OBJECTID';
 const REFRESH_TOKEN_TIMEOUT = 1800;
 const CESIUM_DATASET_PREFIX = 'https://';
+
 export default class I3SConverter {
   constructor() {
     _defineProperty(this, "nodePages", void 0);
-
     _defineProperty(this, "options", void 0);
-
     _defineProperty(this, "layers0Path", void 0);
-
     _defineProperty(this, "materialMap", void 0);
-
     _defineProperty(this, "materialDefinitions", void 0);
-
+    _defineProperty(this, "geometryMap", void 0);
+    _defineProperty(this, "geometryConfigs", void 0);
     _defineProperty(this, "vertexCounter", void 0);
-
     _defineProperty(this, "layers0", void 0);
-
     _defineProperty(this, "featuresHashArray", void 0);
-
     _defineProperty(this, "refinementCounter", void 0);
-
     _defineProperty(this, "validate", void 0);
-
     _defineProperty(this, "boundingVolumeWarnings", []);
-
     _defineProperty(this, "conversionStartTime", [0, 0]);
-
     _defineProperty(this, "refreshTokenTime", [0, 0]);
-
     _defineProperty(this, "sourceTileset", null);
-
     _defineProperty(this, "geoidHeightModel", null);
-
     _defineProperty(this, "Loader", Tiles3DLoader);
-
     _defineProperty(this, "generateTextures", void 0);
-
     _defineProperty(this, "generateBoundingVolumes", void 0);
-
     _defineProperty(this, "layersHasTexture", void 0);
-
     _defineProperty(this, "workerSource", {});
-
     _defineProperty(this, "writeQueue", new WriteQueue());
-
-    this.nodePages = new NodePages(writeFile, HARDCODED_NODES_PER_PAGE);
+    _defineProperty(this, "compressList", null);
+    this.nodePages = new NodePages(writeFile, HARDCODED_NODES_PER_PAGE, this);
     this.options = {};
     this.layers0Path = '';
     this.materialMap = new Map();
     this.materialDefinitions = [];
+    this.geometryMap = new Map();
+    this.geometryConfigs = [];
     this.vertexCounter = 0;
     this.layers0 = null;
     this.featuresHashArray = [];
@@ -100,6 +83,7 @@ export default class I3SConverter {
     this.generateTextures = false;
     this.generateBoundingVolumes = false;
     this.layersHasTexture = false;
+    this.compressList = null;
   }
 
   async convert(options) {
@@ -107,7 +91,6 @@ export default class I3SConverter {
       console.log(BROWSER_ERROR_MESSAGE);
       return BROWSER_ERROR_MESSAGE;
     }
-
     this.conversionStartTime = process.hrtime();
     const {
       tilesetName,
@@ -116,12 +99,14 @@ export default class I3SConverter {
       inputUrl,
       validate,
       outputPath,
-      draco,
+      draco = true,
       sevenZipExe,
       maxDepth,
       token,
       generateTextures,
-      generateBoundingVolumes
+      generateBoundingVolumes,
+      instantNodeWriting = false,
+      mergeMaterials = true
     } = options;
     this.options = {
       maxDepth,
@@ -130,8 +115,11 @@ export default class I3SConverter {
       egmFilePath,
       draco,
       token,
-      inputUrl
+      inputUrl,
+      instantNodeWriting,
+      mergeMaterials
     };
+    this.compressList = this.options.instantNodeWriting && [] || null;
     this.validate = Boolean(validate);
     this.Loader = inputUrl.indexOf(CESIUM_DATASET_PREFIX) !== -1 ? CesiumIonLoader : Tiles3DLoader;
     this.generateTextures = Boolean(generateTextures);
@@ -145,29 +133,35 @@ export default class I3SConverter {
     if (slpk) {
       this.nodePages.useWriteFunction(writeFileForSlpk);
     }
-
     await this.loadWorkers();
-
     try {
+      var _sourceTilesetJson$ro, _sourceTilesetJson$ro2;
       const preloadOptions = await this._fetchPreloadOptions();
       const tilesetOptions = {
         loadOptions: {
+          _nodeWorkers: true,
+          reuseWorkers: true,
           basis: {
             format: 'rgba32'
+          },
+          'basis-nodejs': {
+            format: 'rgba32',
+            workerUrl: './modules/textures/dist/basis-nodejs-worker.js'
+          },
+          'draco-nodejs': {
+            workerUrl: './modules/draco/dist/draco-nodejs-worker.js'
           }
         }
       };
-
       if (preloadOptions.headers) {
         tilesetOptions.loadOptions.fetch = {
           headers: preloadOptions.headers
         };
       }
-
       Object.assign(tilesetOptions, preloadOptions);
       const sourceTilesetJson = await load(inputUrl, this.Loader, tilesetOptions.loadOptions);
       this.sourceTileset = new Tileset3D(sourceTilesetJson, tilesetOptions);
-      await this._createAndSaveTileset(outputPath, tilesetName);
+      await this._createAndSaveTileset(outputPath, tilesetName, sourceTilesetJson === null || sourceTilesetJson === void 0 ? void 0 : (_sourceTilesetJson$ro = sourceTilesetJson.root) === null || _sourceTilesetJson$ro === void 0 ? void 0 : (_sourceTilesetJson$ro2 = _sourceTilesetJson$ro.boundingVolume) === null || _sourceTilesetJson$ro2 === void 0 ? void 0 : _sourceTilesetJson$ro2.region);
       await this._finishConversion({
         slpk: Boolean(slpk),
         outputPath,
@@ -182,50 +176,54 @@ export default class I3SConverter {
     }
   }
 
-  async _createAndSaveTileset(outputPath, tilesetName) {
+  async _createAndSaveTileset(outputPath, tilesetName, boundingVolumeRegion) {
     const tilesetPath = join("".concat(outputPath), "".concat(tilesetName));
-
     try {
       await removeDir(tilesetPath);
-    } catch (e) {}
-
+    } catch (e) {
+    }
     this.layers0Path = join(tilesetPath, 'SceneServer', 'layers', '0');
-
-    this._formLayers0(tilesetName);
-
+    this._formLayers0(tilesetName, boundingVolumeRegion);
     this.materialDefinitions = [];
     this.materialMap = new Map();
     const sourceRootTile = this.sourceTileset.root;
     const boundingVolumes = createBoundingVolumes(sourceRootTile, this.geoidHeightModel);
-    const parentId = this.nodePages.push({
+    await this.nodePages.push({
       index: 0,
       lodThreshold: 0,
       obb: boundingVolumes.obb,
       children: []
     });
-    const isCreateSlpk = this.options.slpk;
-
-    const root0 = this._formRootNodeIndexDocument(boundingVolumes);
-
-    await this._convertNodesTree(root0, sourceRootTile, parentId, boundingVolumes);
+    const rootNode = await NodeIndexDocument.createRootNode(boundingVolumes, this);
+    await this._convertNodesTree(rootNode, sourceRootTile);
     this.layers0.materialDefinitions = this.materialDefinitions;
-
+    this.layers0.geometryDefinitions = transform(this.geometryConfigs.map(config => ({
+      geometryConfig: {
+        ...config,
+        draco: this.options.draco
+      }
+    })), geometryDefinitionTemlate());
     if (this.layersHasTexture === false) {
       this.layers0.store.defaultGeometrySchema.ordering = this.layers0.store.defaultGeometrySchema.ordering.filter(attribute => attribute !== 'uv0');
     }
-
     await this._writeLayers0();
     createSceneServerPath(tilesetName, this.layers0, tilesetPath);
-    await this._writeNodeIndexDocument(root0, 'root', join(this.layers0Path, 'nodes', 'root'));
-    await this.nodePages.save(this.layers0Path, this.writeQueue, isCreateSlpk);
+    for (const filePath of this.compressList || []) {
+      await compressFileWithGzip(filePath);
+      await removeFile(filePath);
+    }
+    await this.nodePages.save();
     await this.writeQueue.finalize();
     await this._createSlpk(tilesetPath);
   }
 
-  _formLayers0(tilesetName) {
+  _formLayers0(tilesetName, boundingVolumeRegion) {
     var _this$sourceTileset, _this$sourceTileset2, _this$sourceTileset2$;
-
     const fullExtent = convertBoundingVolumeToI3SFullExtent(((_this$sourceTileset = this.sourceTileset) === null || _this$sourceTileset === void 0 ? void 0 : _this$sourceTileset.boundingVolume) || ((_this$sourceTileset2 = this.sourceTileset) === null || _this$sourceTileset2 === void 0 ? void 0 : (_this$sourceTileset2$ = _this$sourceTileset2.root) === null || _this$sourceTileset2$ === void 0 ? void 0 : _this$sourceTileset2$.boundingVolume));
+    if (boundingVolumeRegion) {
+      fullExtent.zmin = boundingVolumeRegion[4];
+      fullExtent.zmax = boundingVolumeRegion[5];
+    }
     const extent = [fullExtent.xmin, fullExtent.ymin, fullExtent.xmax, fullExtent.ymax];
     const layers0data = {
       version: "{".concat(uuidv4().toUpperCase(), "}"),
@@ -245,81 +243,34 @@ export default class I3SConverter {
     this.layers0 = transform(layers0data, layersTemplate());
   }
 
-  _formRootNodeIndexDocument(boundingVolumes) {
-    const root0data = {
-      version: "{".concat(uuidv4().toUpperCase(), "}"),
-      id: 'root',
-      level: 0,
-      lodSelection: [{
-        metricType: 'maxScreenThresholdSQ',
-        maxError: 0
-      }, {
-        metricType: 'maxScreenThreshold',
-        maxError: 0
-      }],
-      ...boundingVolumes,
-      children: []
-    };
-    return transform(root0data, nodeTemplate());
-  }
-
-  async _convertNodesTree(root0, sourceRootTile, parentId, boundingVolumes) {
+  async _convertNodesTree(rootNode, sourceRootTile) {
     await this.sourceTileset._loadTile(sourceRootTile);
-
     if (this.isContentSupported(sourceRootTile)) {
-      root0.children = root0.children || [];
-      root0.children.push({
-        id: '1',
-        href: './1',
-        ...boundingVolumes
-      });
-      const [child] = await this._createNode(root0, sourceRootTile, parentId, 0);
-      const childPath = join(this.layers0Path, 'nodes', child.path);
-
-      if (this.options.slpk) {
-        this.writeQueue.enqueue({
-          archiveKey: 'nodes/1/3dNodeIndexDocument.json.gz',
-          writePromise: writeFileForSlpk(childPath, JSON.stringify(child), '3dNodeIndexDocument.json')
-        });
-      } else {
-        this.writeQueue.enqueue({
-          writePromise: writeFile(childPath, JSON.stringify(child))
-        });
+      const childNodes = await this._createNode(rootNode, sourceRootTile, 0);
+      for (const childNode of childNodes) {
+        await childNode.save();
       }
+      await rootNode.addChildren(childNodes);
     } else {
       await this._addChildrenWithNeighborsAndWriteFile({
-        parentNode: root0,
+        parentNode: rootNode,
         sourceTiles: sourceRootTile.children,
-        parentId,
         level: 1
       });
     }
-
     await sourceRootTile.unloadContent();
+    await rootNode.save();
   }
 
   async _writeLayers0() {
     if (this.options.slpk) {
-      this.writeQueue.enqueue({
+      await this.writeQueue.enqueue({
         archiveKey: '3dSceneLayer.json.gz',
-        writePromise: writeFileForSlpk(this.layers0Path, JSON.stringify(this.layers0), '3dSceneLayer.json')
+        writePromise: () => writeFileForSlpk(this.layers0Path, JSON.stringify(this.layers0), '3dSceneLayer.json')
       });
     } else {
-      this.writeQueue.enqueue({
-        writePromise: writeFile(this.layers0Path, JSON.stringify(this.layers0))
-      });
-    }
-  }
-
-  async _writeNodeIndexDocument(root0, nodePath, rootPath) {
-    if (this.options.slpk) {
-      this.writeQueue.enqueue({
-        archiveKey: "nodes/".concat(nodePath, "/3dNodeIndexDocument.json.gz"),
-        writePromise: writeFileForSlpk(rootPath, JSON.stringify(root0), '3dNodeIndexDocument.json')
-      });
-    } else {
-      this.writeQueue.enqueue({
-        writePromise: writeFile(rootPath, JSON.stringify(root0))
+      await this.writeQueue.enqueue({
+        writePromise: () => writeFile(this.layers0Path, JSON.stringify(this.layers0))
       });
     }
   }
@@ -332,115 +283,89 @@ export default class I3SConverter {
 
       try {
         await removeDir(tilesetPath);
-      } catch (e) {}
+      } catch (e) {
+      }
     }
   }
 
   async _addChildrenWithNeighborsAndWriteFile(data) {
-    const childNodes = [];
-    await this._addChildren({ ...data,
-      childNodes
+    await this._addChildren(data);
+    await data.parentNode.addNeighbors();
+  }
+
+  async convertNestedTileset(_ref) {
+    let {
+      parentNode,
+      sourceTile,
+      level
+    } = _ref;
+    await this.sourceTileset._loadTile(sourceTile);
+    await this._addChildren({
+      parentNode,
+      sourceTiles: sourceTile.children,
+      level: level + 1
     });
-    await this._addNeighborsAndWriteFile(data.parentNode, childNodes);
+    await sourceTile.unloadContent();
+  }
+
+  async convertNode(_ref2) {
+    let {
+      parentNode,
+      sourceTile,
+      level
+    } = _ref2;
+    const childNodes = await this._createNode(parentNode, sourceTile, level);
+    await parentNode.addChildren(childNodes);
   }
 
   async _addChildren(data) {
     const {
-      childNodes,
       sourceTiles,
       parentNode,
-      parentId,
       level
     } = data;
-
     if (this.options.maxDepth && level > this.options.maxDepth) {
       return;
     }
-
     for (const sourceTile of sourceTiles) {
       if (sourceTile.type === 'json') {
-        await this.sourceTileset._loadTile(sourceTile);
-        await this._addChildren({
+        await this.convertNestedTileset({
           parentNode,
-          sourceTiles: sourceTile.children,
-          childNodes,
-          parentId,
-          level: level + 1
+          sourceTile,
+          level
         });
-        await sourceTile.unloadContent();
       } else {
-        const children = await this._createNode(parentNode, sourceTile, parentId, level);
-        parentNode.children = parentNode.children || [];
-
-        for (const child of children) {
-          parentNode.children.push({
-            id: child.id,
-            href: "../".concat(child.path),
-            obb: child.obb,
-            mbs: child.mbs
-          });
-          childNodes.push(child);
-        }
+        await this.convertNode({
+          parentNode,
+          sourceTile,
+          level
+        });
       }
-
       if (sourceTile.id) {
         console.log(sourceTile.id);
       }
     }
   }
 
-  async _addNeighborsAndWriteFile(parentNode, childNodes) {
-    for (const node of childNodes) {
-      var _parentNode$children;
-
-      const childPath = join(this.layers0Path, 'nodes', node.path);
-      const nodePath = node.path;
-      delete node.path;
-
-      if (Number(parentNode === null || parentNode === void 0 ? void 0 : (_parentNode$children = parentNode.children) === null || _parentNode$children === void 0 ? void 0 : _parentNode$children.length) < 1000) {
-        for (const neighbor of parentNode.children || []) {
-          if (node.id === neighbor.id) {
-            continue;
-          }
-
-          if (node.neighbors) {
-            node.neighbors.push({ ...neighbor
-            });
-          }
-        }
-      } else {
-        console.warn("Node ".concat(node.id, ": neighbors attribute is omited because of large number of neigbors"));
-        delete node.neighbors;
-      }
-
-      await this._writeNodeIndexDocument(node, nodePath, childPath);
-      node.neighbors = [];
-    }
-  }
-
-  async _createNode(parentTile, sourceTile, parentId, level) {
-    var _sourceTile$content;
-
-    if (this.validate) {
-      this._checkAddRefinementTypeForTile(sourceTile);
-    }
-
+  async _createNode(parentNode, sourceTile, level) {
+    var _this$layers, _this$layers$attribut;
+    this._checkAddRefinementTypeForTile(sourceTile);
     await this._updateTilesetOptions();
     await this.sourceTileset._loadTile(sourceTile);
     let boundingVolumes = createBoundingVolumes(sourceTile, this.geoidHeightModel);
-    const batchTable = sourceTile === null || sourceTile === void 0 ? void 0 : (_sourceTile$content = sourceTile.content) === null || _sourceTile$content === void 0 ? void 0 : _sourceTile$content.batchTableJson;
-
-    if (batchTable) {
-      this._convertAttributeStorageInfo(sourceTile.content);
+    const propertyTable = getPropertyTable(sourceTile.content);
+    if (propertyTable && !((_this$layers = this.layers0) !== null && _this$layers !== void 0 && (_this$layers$attribut = _this$layers.attributeStorageInfo) !== null && _this$layers$attribut !== void 0 && _this$layers$attribut.length)) {
+      this._convertPropertyTableToNodeAttributes(propertyTable);
     }
-
-    const resourcesData = await this._convertResources(sourceTile);
+    const resourcesData = await this._convertResources(sourceTile, parentNode.inPageId, propertyTable);
     const nodes = [];
+    const nodeIds = [];
     const nodesInPage = [];
     const emptyResources = {
       geometry: null,
       compressedGeometry: null,
       texture: null,
+      hasUvRegions: false,
       sharedResources: null,
       meshMaterial: null,
       vertexCount: null,
@@ -448,77 +373,66 @@ export default class I3SConverter {
       featureCount: null,
       boundingVolumes: null
     };
-
     for (const resources of resourcesData || [emptyResources]) {
       this.layersHasTexture = this.layersHasTexture || Boolean(resources.texture);
-
       if (this.generateBoundingVolumes && resources.boundingVolumes) {
         boundingVolumes = resources.boundingVolumes;
       }
-
       const lodSelection = convertGeometricErrorToScreenThreshold(sourceTile, boundingVolumes);
       const maxScreenThresholdSQ = lodSelection.find(val => val.metricType === 'maxScreenThresholdSQ') || {
         maxError: 0
       };
-
-      const nodeInPage = this._createNodeInNodePages(maxScreenThresholdSQ, boundingVolumes, sourceTile, parentId, resources);
-
-      const node = this._createNodeIndexDocument(parentTile, boundingVolumes, lodSelection, nodeInPage, resources);
-
+      const nodeInPage = await this._updateNodeInNodePages(maxScreenThresholdSQ, boundingVolumes, sourceTile, parentNode.inPageId, resources);
+      const nodeData = await NodeIndexDocument.createNodeIndexDocument(parentNode, boundingVolumes, lodSelection, nodeInPage, resources);
+      const node = await new NodeIndexDocument(nodeInPage.index, this).addData(nodeData);
+      nodes.push(node);
       if (nodeInPage.mesh) {
-        await this._writeResources(resources, node.path);
+        await this._writeResources(resources, node.id);
       }
-
       if (this.validate) {
-        this.boundingVolumeWarnings = validateNodeBoundingVolumes(node);
-
+        this.boundingVolumeWarnings = validateNodeBoundingVolumes(nodeData);
         if (this.boundingVolumeWarnings && this.boundingVolumeWarnings.length) {
           console.warn('Bounding Volume Warnings: ', ...this.boundingVolumeWarnings);
         }
       }
 
-      nodes.push(node);
+      nodeIds.push(nodeInPage.index);
       nodesInPage.push(nodeInPage);
     }
-
     sourceTile.unloadContent();
     await this._addChildrenWithNeighborsAndWriteFile({
       parentNode: nodes[0],
       sourceTiles: sourceTile.children,
-      parentId: nodesInPage[0].index,
       level: level + 1
     });
     return nodes;
   }
 
-  _convertAttributeStorageInfo(sourceTileContent) {
-    var _this$layers, _this$layers$attribut;
-
-    const batchTable = sourceTileContent && sourceTileContent.batchTableJson;
-
-    if (batchTable && !((_this$layers = this.layers0) !== null && _this$layers !== void 0 && (_this$layers$attribut = _this$layers.attributeStorageInfo) !== null && _this$layers$attribut !== void 0 && _this$layers$attribut.length)) {
-      this._convertBatchTableInfoToNodeAttributes(batchTable);
-    }
-  }
-
-  async _convertResources(sourceTile) {
+  async _convertResources(sourceTile, parentId, propertyTable) {
     var _this$layers2;
-
     if (!this.isContentSupported(sourceTile)) {
       return null;
     }
-
-    const resourcesData = await convertB3dmToI3sGeometry(sourceTile.content, Number(this.nodePages.nodesCounter), this.featuresHashArray, (_this$layers2 = this.layers0) === null || _this$layers2 === void 0 ? void 0 : _this$layers2.attributeStorageInfo, this.options.draco, this.generateBoundingVolumes, this.geoidHeightModel, this.workerSource);
+    const draftObb = {
+      center: [],
+      halfSize: [],
+      quaternion: []
+    };
+    const resourcesData = await convertB3dmToI3sGeometry(sourceTile.content, async () => (await this.nodePages.push({
+      index: 0,
+      obb: draftObb
+    }, parentId)).index, propertyTable, this.featuresHashArray, (_this$layers2 = this.layers0) === null || _this$layers2 === void 0 ? void 0 : _this$layers2.attributeStorageInfo, this.options.draco, this.generateBoundingVolumes, this.options.mergeMaterials, this.geoidHeightModel, this.workerSource);
     return resourcesData;
   }
 
-  _createNodeInNodePages(maxScreenThresholdSQ, boundingVolumes, sourceTile, parentId, resources) {
+  async _updateNodeInNodePages(maxScreenThresholdSQ, boundingVolumes, sourceTile, parentId, resources) {
     const {
       meshMaterial,
       texture,
       vertexCount,
       featureCount,
-      geometry
+      geometry,
+      hasUvRegions
     } = resources;
     const nodeInPage = {
       index: 0,
@@ -526,11 +440,10 @@ export default class I3SConverter {
       obb: boundingVolumes.obb,
       children: []
     };
-
     if (geometry && this.isContentSupported(sourceTile)) {
       nodeInPage.mesh = {
         geometry: {
-          definition: texture ? 0 : 1,
+          definition: this.findOrCreateGeometryDefinition(Boolean(texture), hasUvRegions),
           resource: 0
         },
         attribute: {
@@ -541,86 +454,30 @@ export default class I3SConverter {
         }
       };
     }
-
-    const nodeId = this.nodePages.push(nodeInPage, parentId);
-
+    let nodeId = resources.nodeId;
+    let node;
+    if (!nodeId) {
+      node = await this.nodePages.push(nodeInPage, parentId);
+    } else {
+      node = await this.nodePages.getNodeById(nodeId);
+    }
+    NodePages.updateAll(node, nodeInPage);
     if (meshMaterial) {
-      this.nodePages.updateMaterialByNodeId(nodeId, this._findOrCreateMaterial(meshMaterial));
+      NodePages.updateMaterialByNodeId(node, this._findOrCreateMaterial(meshMaterial));
     }
-
     if (texture) {
       const texelCountHint = texture.image.height * texture.image.width;
-      this.nodePages.updateTexelCountHintByNodeId(nodeId, texelCountHint);
+      NodePages.updateTexelCountHintByNodeId(node, texelCountHint);
     }
-
     if (vertexCount) {
       this.vertexCounter += vertexCount;
-      this.nodePages.updateVertexCountByNodeId(nodeId, vertexCount);
+      NodePages.updateVertexCountByNodeId(node, vertexCount);
     }
-
-    this.nodePages.updateNodeAttributeByNodeId(nodeId);
-
+    NodePages.updateNodeAttributeByNodeId(node);
     if (featureCount) {
-      this.nodePages.updateFeatureCountByNodeId(nodeId, featureCount);
+      NodePages.updateFeatureCountByNodeId(node, featureCount);
     }
-
-    return nodeInPage;
-  }
-
-  _createNodeIndexDocument(parentNode, boundingVolumes, lodSelection, nodeInPage, resources) {
-    const {
-      texture,
-      attributes
-    } = resources;
-    const nodeId = nodeInPage.index;
-    const nodeData = {
-      version: parentNode.version,
-      id: nodeId.toString(),
-      path: nodeId.toString(),
-      level: parentNode.level + 1,
-      ...boundingVolumes,
-      lodSelection,
-      parentNode: {
-        id: parentNode.id,
-        href: "../".concat(parentNode.id),
-        mbs: parentNode.mbs,
-        obb: parentNode.obb
-      },
-      children: [],
-      neighbors: []
-    };
-    const node = transform(nodeData, nodeTemplate());
-
-    if (nodeInPage.mesh) {
-      var _this$layers3, _this$layers3$attribu;
-
-      node.geometryData = [{
-        href: './geometries/0'
-      }];
-      node.sharedResource = {
-        href: './shared'
-      };
-
-      if (texture) {
-        node.textureData = [{
-          href: './textures/0'
-        }, {
-          href: './textures/1'
-        }];
-      }
-
-      if (attributes && attributes.length && (_this$layers3 = this.layers0) !== null && _this$layers3 !== void 0 && (_this$layers3$attribu = _this$layers3.attributeStorageInfo) !== null && _this$layers3$attribu !== void 0 && _this$layers3$attribu.length) {
-        node.attributeData = [];
-
-        for (let index = 0; index < attributes.length; index++) {
-          const folderName = this.layers0.attributeStorageInfo[index].key;
-          node.attributeData.push({
-            href: "./attributes/".concat(folderName, "/0")
-          });
-        }
-      }
-    }
-
+    this.nodePages.saveNode(node);
     return node;
   }
 
@@ -643,28 +500,27 @@ export default class I3SConverter {
   async _writeGeometries(geometryBuffer, compressedGeometry, childPath, slpkChildPath) {
     if (this.options.slpk) {
       const slpkGeometryPath = join(childPath, 'geometries');
-      this.writeQueue.enqueue({
+      await this.writeQueue.enqueue({
         archiveKey: "".concat(slpkChildPath, "/geometries/0.bin.gz"),
-        writePromise: writeFileForSlpk(slpkGeometryPath, geometryBuffer, '0.bin')
+        writePromise: () => writeFileForSlpk(slpkGeometryPath, geometryBuffer, '0.bin')
       });
     } else {
       const geometryPath = join(childPath, 'geometries/0/');
-      this.writeQueue.enqueue({
-        writePromise: writeFile(geometryPath, geometryBuffer, 'index.bin')
+      await this.writeQueue.enqueue({
+        writePromise: () => writeFile(geometryPath, geometryBuffer, 'index.bin')
       });
     }
-
     if (this.options.draco) {
       if (this.options.slpk) {
         const slpkCompressedGeometryPath = join(childPath, 'geometries');
-        this.writeQueue.enqueue({
+        await this.writeQueue.enqueue({
           archiveKey: "".concat(slpkChildPath, "/geometries/1.bin.gz"),
-          writePromise: writeFileForSlpk(slpkCompressedGeometryPath, compressedGeometry, '1.bin')
+          writePromise: () => writeFileForSlpk(slpkCompressedGeometryPath, compressedGeometry, '1.bin')
         });
       } else {
         const compressedGeometryPath = join(childPath, 'geometries/1/');
-        this.writeQueue.enqueue({
-          writePromise: writeFile(compressedGeometryPath, compressedGeometry, 'index.bin')
+        await this.writeQueue.enqueue({
+          writePromise: () => writeFile(compressedGeometryPath, compressedGeometry, 'index.bin')
         });
       }
     }
@@ -674,21 +530,19 @@ export default class I3SConverter {
     if (!sharedResources) {
       return;
     }
-
     sharedResources.nodePath = nodePath;
     const sharedData = transform(sharedResources, sharedResourcesTemplate());
     const sharedDataStr = JSON.stringify(sharedData);
-
     if (this.options.slpk) {
       const slpkSharedPath = join(childPath, 'shared');
-      this.writeQueue.enqueue({
+      await this.writeQueue.enqueue({
         archiveKey: "".concat(slpkChildPath, "/shared/sharedResource.json.gz"),
-        writePromise: writeFileForSlpk(slpkSharedPath, sharedDataStr, 'sharedResource.json')
+        writePromise: () => writeFileForSlpk(slpkSharedPath, sharedDataStr, 'sharedResource.json')
       });
     } else {
       const sharedPath = join(childPath, 'shared/');
-      this.writeQueue.enqueue({
-        writePromise: writeFile(sharedPath, sharedDataStr)
+      await this.writeQueue.enqueue({
+        writePromise: () => writeFile(sharedPath, sharedDataStr)
       });
     }
   }
@@ -696,10 +550,8 @@ export default class I3SConverter {
   async _writeTexture(texture, childPath, slpkChildPath) {
     if (texture) {
       const format = this._getFormatByMimeType(texture === null || texture === void 0 ? void 0 : texture.mimeType);
-
       const formats = [];
       const textureData = texture.bufferView.data;
-
       switch (format) {
         case 'jpg':
         case 'png':
@@ -709,7 +561,6 @@ export default class I3SConverter {
               format
             });
             await this.writeTextureFile(textureData, '0', format, childPath, slpkChildPath);
-
             if (this.generateTextures) {
               formats.push({
                 name: '1',
@@ -717,19 +568,19 @@ export default class I3SConverter {
               });
               const copyArrayBuffer = texture.image.data.subarray();
               const arrayToEncode = new Uint8Array(copyArrayBuffer);
-              const ktx2TextureData = encode({ ...texture.image,
+              const ktx2TextureData = encode({
+                ...texture.image,
                 data: arrayToEncode
-              }, KTX2BasisWriterWorker, { ...KTX2BasisWriterWorker.options,
+              }, KTX2BasisWriterWorker, {
+                ...KTX2BasisWriterWorker.options,
                 source: this.workerSource.ktx2,
                 reuseWorkers: true,
                 _nodeWorkers: true
               });
               await this.writeTextureFile(ktx2TextureData, '1', 'ktx2', childPath, slpkChildPath);
             }
-
             break;
           }
-
         case 'ktx2':
           {
             formats.push({
@@ -737,7 +588,6 @@ export default class I3SConverter {
               format
             });
             await this.writeTextureFile(textureData, '1', format, childPath, slpkChildPath);
-
             if (this.generateTextures) {
               formats.push({
                 name: '0',
@@ -748,11 +598,14 @@ export default class I3SConverter {
             }
           }
       }
-
       if (!this.layers0.textureSetDefinitions.length) {
         this.layers0.textureSetDefinitions.push({
           formats
         });
+        this.layers0.textureSetDefinitions.push({
+          formats,
+          atlas: true
+        });
       }
     }
   }
@@ -761,36 +614,37 @@ export default class I3SConverter {
     if (this.options.slpk) {
       const slpkTexturePath = join(childPath, 'textures');
       const compress = false;
-      this.writeQueue.enqueue({
+      await this.writeQueue.enqueue({
         archiveKey: "".concat(slpkChildPath, "/textures/").concat(name, ".").concat(format),
-        writePromise: writeFileForSlpk(slpkTexturePath, textureData, "".concat(name, ".").concat(format), compress)
+        writePromise: () => writeFileForSlpk(slpkTexturePath, textureData, "".concat(name, ".").concat(format), compress)
       });
     } else {
       const texturePath = join(childPath, "textures/".concat(name, "/"));
-      this.writeQueue.enqueue({
-        writePromise: writeFile(texturePath, textureData, "index.".concat(format))
+      await this.writeQueue.enqueue({
+        writePromise: () => writeFile(texturePath, textureData, "index.".concat(format))
       });
     }
   }
 
-  async _writeAttributes(attributes = [], childPath, slpkChildPath) {
-    var _this$layers4, _this$layers4$attribu;
-
-    if (attributes !== null && attributes !== void 0 && attributes.length && (_this$layers4 = this.layers0) !== null && _this$layers4 !== void 0 && (_this$layers4$attribu = _this$layers4.attributeStorageInfo) !== null && _this$layers4$attribu !== void 0 && _this$layers4$attribu.length) {
+  async _writeAttributes() {
+    var _this$layers3, _this$layers3$attribu;
+    let attributes = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+    let childPath = arguments.length > 1 ? arguments[1] : undefined;
+    let slpkChildPath = arguments.length > 2 ? arguments[2] : undefined;
+    if (attributes !== null && attributes !== void 0 && attributes.length && (_this$layers3 = this.layers0) !== null && _this$layers3 !== void 0 && (_this$layers3$attribu = _this$layers3.attributeStorageInfo) !== null && _this$layers3$attribu !== void 0 && _this$layers3$attribu.length) {
       for (let index = 0; index < attributes.length; index++) {
         const folderName = this.layers0.attributeStorageInfo[index].key;
         const fileBuffer = new Uint8Array(attributes[index]);
-
         if (this.options.slpk) {
           const slpkAttributesPath = join(childPath, 'attributes', folderName);
-          this.writeQueue.enqueue({
+          await this.writeQueue.enqueue({
             archiveKey: "".concat(slpkChildPath, "/attributes/").concat(folderName, ".bin.gz"),
-            writePromise: writeFileForSlpk(slpkAttributesPath, fileBuffer, '0.bin')
+            writePromise: () => writeFileForSlpk(slpkAttributesPath, fileBuffer, '0.bin')
           });
         } else {
           const attributesPath = join(childPath, "attributes/".concat(folderName, "/0"));
-          this.writeQueue.enqueue({
-            writePromise: writeFile(attributesPath, fileBuffer, 'index.bin')
+          await this.writeQueue.enqueue({
+            writePromise: () => writeFile(attributesPath, fileBuffer, 'index.bin')
           });
         }
       }
@@ -801,13 +655,10 @@ export default class I3SConverter {
     switch (mimeType) {
       case 'image/jpeg':
         return 'jpg';
-
       case 'image/png':
         return 'png';
-
       case 'image/ktx2':
         return 'ktx2';
-
       default:
         return 'jpg';
     }
@@ -815,130 +666,41 @@ export default class I3SConverter {
 
   _findOrCreateMaterial(material) {
     const hash = md5(JSON.stringify(material));
-
     if (this.materialMap.has(hash)) {
-      return this.materialMap.get(hash);
+      return this.materialMap.get(hash) || 0;
     }
-
     const newMaterialId = this.materialDefinitions.push(material) - 1;
     this.materialMap.set(hash, newMaterialId);
     return newMaterialId;
   }
 
-  _createdStorageAttribute(attributeIndex, key, attributeType) {
-    const storageAttribute = {
-      key: "f_".concat(attributeIndex),
-      name: key,
-      ordering: ['attributeValues'],
-      header: [{
-        property: 'count',
-        valueType: 'UInt32'
-      }],
-      attributeValues: {
-        valueType: 'Int32',
-        valuesPerElement: 1
-      }
+  findOrCreateGeometryDefinition(hasTexture, hasUvRegions) {
+    const geometryConfig = {
+      hasTexture,
+      hasUvRegions
     };
-
-    switch (attributeType) {
-      case OBJECT_ID_TYPE:
-        this._setupIdAttribute(storageAttribute);
-
-        break;
-
-      case STRING_TYPE:
-        this._setupStringAttribute(storageAttribute);
-
-        break;
-
-      case DOUBLE_TYPE:
-        this._setupDoubleAttribute(storageAttribute);
-
-        break;
-
-      case SHORT_INT_TYPE:
-        break;
-
-      default:
-        this._setupStringAttribute(storageAttribute);
-
-    }
-
-    return storageAttribute;
-  }
-
-  getAttributeType(key, attribute) {
-    if (key === OBJECT_ID_TYPE) {
-      return OBJECT_ID_TYPE;
-    }
-
-    if (typeof attribute === STRING_TYPE) {
-      return STRING_TYPE;
-    } else if (typeof attribute === 'number') {
-      return Number.isInteger(attribute) ? SHORT_INT_TYPE : DOUBLE_TYPE;
+    const hash = md5(JSON.stringify(geometryConfig));
+    if (this.geometryMap.has(hash)) {
+      return this.geometryMap.get(hash) || 0;
     }
-
-    return STRING_TYPE;
-  }
-
-  _setupStringAttribute(storageAttribute) {
-    storageAttribute.ordering.unshift('attributeByteCounts');
-    storageAttribute.header.push({
-      property: 'attributeValuesByteCount',
-      valueType: 'UInt32'
-    });
-    storageAttribute.attributeValues = {
-      valueType: 'String',
-      encoding: 'UTF-8',
-      valuesPerElement: 1
-    };
-    storageAttribute.attributeByteCounts = {
-      valueType: 'UInt32',
-      valuesPerElement: 1
-    };
+    const newGeometryId = this.geometryConfigs.push(geometryConfig) - 1;
+    this.geometryMap.set(hash, newGeometryId);
+    return newGeometryId;
   }
 
-  _setupIdAttribute(storageAttribute) {
-    storageAttribute.attributeValues = {
-      valueType: 'Oid32',
-      valuesPerElement: 1
-    };
-  }
-
-  _setupDoubleAttribute(storageAttribute) {
-    storageAttribute.attributeValues = {
-      valueType: 'Float64',
-      valuesPerElement: 1
-    };
-  }
-
-  _createFieldAttribute(key, fieldAttributeType) {
-    return {
-      name: key,
-      type: fieldAttributeType,
-      alias: key
-    };
-  }
-
-  _convertBatchTableInfoToNodeAttributes(batchTable) {
+  _convertPropertyTableToNodeAttributes(propertyTable) {
     let attributeIndex = 0;
-    const batchTableWithObjectId = {
+    const propertyTableWithObjectId = {
       OBJECTID: [0],
-      ...batchTable
+      ...propertyTable
     };
-
-    for (const key in batchTableWithObjectId) {
-      const firstAttribute = batchTableWithObjectId[key][0];
-      const attributeType = this.getAttributeType(key, firstAttribute);
-
-      const storageAttribute = this._createdStorageAttribute(attributeIndex, key, attributeType);
-
-      const fieldAttributeType = this._getFieldAttributeType(attributeType);
-
-      const fieldAttribute = this._createFieldAttribute(key, fieldAttributeType);
-
-      const popupInfo = this._createPopupInfo(batchTableWithObjectId);
-
+    for (const key in propertyTableWithObjectId) {
+      const firstAttribute = propertyTableWithObjectId[key][0];
+      const attributeType = getAttributeType(key, firstAttribute);
+      const storageAttribute = createdStorageAttribute(attributeIndex, key, attributeType);
+      const fieldAttributeType = getFieldAttributeType(attributeType);
+      const fieldAttribute = createFieldAttribute(key, fieldAttributeType);
+      const popupInfo = createPopupInfo(propertyTableWithObjectId);
       this.layers0.attributeStorageInfo.push(storageAttribute);
       this.layers0.fields.push(fieldAttribute);
       this.layers0.popupInfo = popupInfo;
@@ -947,54 +709,6 @@ export default class I3SConverter {
     }
   }
 
-  _getFieldAttributeType(attributeType) {
-    switch (attributeType) {
-      case OBJECT_ID_TYPE:
-        return 'esriFieldTypeOID';
-
-      case STRING_TYPE:
-        return 'esriFieldTypeString';
-
-      case SHORT_INT_TYPE:
-        return 'esriFieldTypeInteger';
-
-      case DOUBLE_TYPE:
-        return 'esriFieldTypeDouble';
-
-      default:
-        return 'esriFieldTypeString';
-    }
-  }
-
-  _createPopupInfo(batchTable) {
-    const title = '{OBJECTID}';
-    const mediaInfos = [];
-    const fieldInfos = [];
-    const popupElements = [];
-    const expressionInfos = [];
-
-    for (const key in batchTable) {
-      fieldInfos.push({
-        fieldName: key,
-        visible: true,
-        isEditable: false,
-        label: key
-      });
-    }
-
-    popupElements.push({
-      fieldInfos,
-      type: 'fields'
-    });
-    return {
-      title,
-      mediaInfos,
-      popupElements,
-      fieldInfos,
-      expressionInfos
-    };
-  }
-
   async _finishConversion(params) {
     const {
       tilesCount,
@@ -1017,7 +731,6 @@ export default class I3SConverter {
     if (!this.Loader.preload) {
       return {};
     }
-
     const options = {
       'cesium-ion': {
         accessToken: this.options.token || ION_DEFAULT_TOKEN
@@ -1025,26 +738,26 @@ export default class I3SConverter {
     };
     const preloadOptions = await this.Loader.preload(this.options.inputUrl, options);
     this.refreshTokenTime = process.hrtime();
-    return { ...options,
+    return {
+      ...options,
       ...preloadOptions
     };
   }
 
   async _updateTilesetOptions() {
     const diff = process.hrtime(this.refreshTokenTime);
-
     if (diff[0] < REFRESH_TOKEN_TIMEOUT) {
       return;
     }
-
     this.refreshTokenTime = process.hrtime();
     const preloadOptions = await this._fetchPreloadOptions();
-    this.sourceTileset.options = { ...this.sourceTileset.options,
+    this.sourceTileset.options = {
+      ...this.sourceTileset.options,
       ...preloadOptions
     };
-
     if (preloadOptions.headers) {
-      this.sourceTileset.loadOptions.fetch = { ...this.sourceTileset.loadOptions.fetch,
+      this.sourceTileset.loadOptions.fetch = {
+        ...this.sourceTileset.loadOptions.fetch,
         headers: preloadOptions.headers
       };
       console.log('Authorization Bearer token has been updated');
@@ -1053,7 +766,6 @@ export default class I3SConverter {
 
   _checkAddRefinementTypeForTile(tile) {
     const ADD_TILE_REFINEMENT = 1;
-
     if (tile.refine === ADD_TILE_REFINEMENT) {
       this.refinementCounter.tilesWithAddRefineCount += 1;
       console.warn('This tile uses "ADD" type of refinement');
@@ -1061,39 +773,35 @@ export default class I3SConverter {
 
     this.refinementCounter.tilesCount += 1;
   }
-
   isContentSupported(sourceRootTile) {
     var _sourceRootTile$conte;
-
     return ['b3dm', 'glTF'].includes(sourceRootTile === null || sourceRootTile === void 0 ? void 0 : (_sourceRootTile$conte = sourceRootTile.content) === null || _sourceRootTile$conte === void 0 ? void 0 : _sourceRootTile$conte.type);
   }
-
   async loadWorkers() {
     console.log("Loading workers source...");
-
     if (this.options.draco) {
-      const url = getWorkerURL(DracoWriterWorker, { ...getLoaderOptions()
+      const url = getWorkerURL(DracoWriterWorker, {
+        ...getLoaderOptions()
       });
       const sourceResponse = await fetchFile(url);
       const source = await sourceResponse.text();
       this.workerSource.draco = source;
     }
-
     if (this.generateTextures) {
-      const url = getWorkerURL(KTX2BasisWriterWorker, { ...getLoaderOptions()
+      const url = getWorkerURL(KTX2BasisWriterWorker, {
+        ...getLoaderOptions()
       });
       const sourceResponse = await fetchFile(url);
       const source = await sourceResponse.text();
       this.workerSource.ktx2 = source;
     }
-
-    const i3sAttributesWorkerUrl = getWorkerURL(I3SAttributesWorker, { ...getLoaderOptions()
+    const i3sAttributesWorkerUrl = getWorkerURL(I3SAttributesWorker, {
+      ...getLoaderOptions()
     });
     const sourceResponse = await fetchFile(i3sAttributesWorkerUrl);
     const source = await sourceResponse.text();
     this.workerSource.I3SAttributes = source;
     console.log("Loading workers source completed!");
   }
-
 }
 //# sourceMappingURL=i3s-converter.js.map