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

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

@@ -1,4 +1,5 @@
 "use strict";
+// loaders.gl, MIT license
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -44,7 +45,7 @@ const create_scene_server_path_1 = require("./helpers/create-scene-server-path")
 const lod_conversion_utils_1 = require("../lib/utils/lod-conversion-utils");
 const pgm_loader_1 = require("../pgm-loader");
 const layers_1 = require("./json-templates/layers");
-const node_1 = require("./json-templates/node");
+const geometry_definitions_1 = require("./json-templates/geometry-definitions");
 const shared_resources_1 = require("./json-templates/shared-resources");
 const node_debug_1 = require("./helpers/node-debug");
 const textures_1 = require("@loaders.gl/textures");
@@ -55,6 +56,7 @@ const write_queue_1 = __importDefault(require("../lib/utils/write-queue"));
 const i3s_attributes_worker_1 = require("../i3s-attributes-worker");
 const constants_1 = require("../constants");
 const feature_attributes_1 = require("./helpers/feature-attributes");
+const node_index_document_1 = require("./helpers/node-index-document");
 const ION_DEFAULT_TOKEN = process_1.default.env?.IonToken || // eslint-disable-line
     'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiJlYWMxMzcyYy0zZjJkLTQwODctODNlNi01MDRkZmMzMjIxOWIiLCJpZCI6OTYyMCwic2NvcGVzIjpbImFzbCIsImFzciIsImdjIl0sImlhdCI6MTU2Mjg2NjI3M30.1FNiClUyk00YH_nWfSGpiQAjR5V2OvREDq1PJ5QMjWQ'; // eslint-disable-line
 const HARDCODED_NODES_PER_PAGE = 64;
@@ -76,11 +78,14 @@ class I3SConverter {
         this.Loader = _3d_tiles_1.Tiles3DLoader;
         this.workerSource = {};
         this.writeQueue = new write_queue_1.default();
-        this.nodePages = new node_pages_1.default(file_utils_1.writeFile, HARDCODED_NODES_PER_PAGE);
+        this.compressList = null;
+        this.nodePages = new node_pages_1.default(file_utils_1.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 = [];
@@ -92,6 +97,7 @@ class I3SConverter {
         this.generateTextures = false;
         this.generateBoundingVolumes = false;
         this.layersHasTexture = false;
+        this.compressList = null;
     }
     /**
      * Convert a 3d tileset
@@ -106,6 +112,9 @@ class I3SConverter {
      * @param options.token Token for Cesium ION tilesets authentication
      * @param options.draco Generate I3S 1.7 draco compressed geometries
      * @param options.validate -enable validation
+     * @param options.generateTextures - generate alternative type of textures (to have non-compressed jpeg/png and compressed ktx2)
+     * @param options.generateBoundingVolumes - generate bounding volumes from vertices coordinates instead of source tiles bounding volumes
+     * @param options.instantNodeWriting - Keep created 3DNodeIndexDocument files on disk instead of memory. This option reduce memory usage but decelerates conversion speed
      */
     async convert(options) {
         if (core_1.isBrowser) {
@@ -113,8 +122,19 @@ class I3SConverter {
             return constants_1.BROWSER_ERROR_MESSAGE;
         }
         this.conversionStartTime = process_1.default.hrtime();
-        const { tilesetName, slpk, egmFilePath, inputUrl, validate, outputPath, draco, sevenZipExe, maxDepth, token, generateTextures, generateBoundingVolumes } = options;
-        this.options = { maxDepth, slpk, sevenZipExe, egmFilePath, draco, token, inputUrl };
+        const { tilesetName, slpk, egmFilePath, inputUrl, validate, outputPath, draco = true, sevenZipExe, maxDepth, token, generateTextures, generateBoundingVolumes, instantNodeWriting = false, mergeMaterials = true } = options;
+        this.options = {
+            maxDepth,
+            slpk,
+            sevenZipExe,
+            egmFilePath,
+            draco,
+            token,
+            inputUrl,
+            instantNodeWriting,
+            mergeMaterials
+        };
+        this.compressList = (this.options.instantNodeWriting && []) || null;
         this.validate = Boolean(validate);
         this.Loader = inputUrl.indexOf(CESIUM_DATASET_PREFIX) !== -1 ? _3d_tiles_1.CesiumIonLoader : _3d_tiles_1.Tiles3DLoader;
         this.generateTextures = Boolean(generateTextures);
@@ -182,24 +202,30 @@ class I3SConverter {
         this.materialMap = new Map();
         const sourceRootTile = this.sourceTileset.root;
         const boundingVolumes = (0, coordinate_converter_1.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 node_index_document_1.NodeIndexDocument.createRootNode(boundingVolumes, this);
+        await this._convertNodesTree(rootNode, sourceRootTile);
         this.layers0.materialDefinitions = this.materialDefinitions;
+        // @ts-ignore
+        this.layers0.geometryDefinitions = (0, json_map_transform_1.default)(this.geometryConfigs.map((config) => ({
+            geometryConfig: { ...config, draco: this.options.draco }
+        })), (0, geometry_definitions_1.GEOMETRY_DEFINITION)());
         if (this.layersHasTexture === false) {
             this.layers0.store.defaultGeometrySchema.ordering =
                 this.layers0.store.defaultGeometrySchema.ordering.filter((attribute) => attribute !== 'uv0');
         }
         await this._writeLayers0();
         (0, create_scene_server_path_1.createSceneServerPath)(tilesetName, this.layers0, tilesetPath);
-        await this._writeNodeIndexDocument(root0, 'root', (0, path_1.join)(this.layers0Path, 'nodes', 'root'));
-        await this.nodePages.save(this.layers0Path, this.writeQueue, isCreateSlpk);
+        for (const filePath of this.compressList || []) {
+            await (0, compress_util_1.compressFileWithGzip)(filePath);
+            await (0, file_utils_1.removeFile)(filePath);
+        }
+        await this.nodePages.save();
         await this.writeQueue.finalize();
         await this._createSlpk(tilesetPath);
     }
@@ -231,68 +257,29 @@ class I3SConverter {
         };
         this.layers0 = (0, json_map_transform_1.default)(layers0data, (0, layers_1.LAYERS)());
     }
-    /**
-     * Convert and save the layer and embedded tiles
-     * @param boundingVolumes - mbs and obb data about node's bounding volume
-     * @return 3DNodeIndexDocument data https://github.com/Esri/i3s-spec/blob/master/docs/1.7/3DNodeIndexDocument.cmn.md
-     */
-    _formRootNodeIndexDocument(boundingVolumes) {
-        const root0data = {
-            version: `{${(0, uuid_1.v4)().toUpperCase()}}`,
-            id: 'root',
-            level: 0,
-            lodSelection: [
-                {
-                    metricType: 'maxScreenThresholdSQ',
-                    maxError: 0
-                },
-                {
-                    metricType: 'maxScreenThreshold',
-                    maxError: 0
-                }
-            ],
-            ...boundingVolumes,
-            children: []
-        };
-        return (0, json_map_transform_1.default)(root0data, (0, node_1.NODE)());
-    }
     /**
      * Form object of 3DSceneLayer https://github.com/Esri/i3s-spec/blob/master/docs/1.7/3DSceneLayer.cmn.md
-     * @param root0 - 3DNodeIndexDocument of root node https://github.com/Esri/i3s-spec/blob/master/docs/1.7/3DNodeIndexDocument.cmn.md
+     * @param rootNode - 3DNodeIndexDocument of root node https://github.com/Esri/i3s-spec/blob/master/docs/1.7/3DNodeIndexDocument.cmn.md
      * @param sourceRootTile - Source (3DTile) tile data
-     * @param parentId - node id in node pages
-     * @param boundingVolumes - mbs and obb data about node's bounding volume
      */
-    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 = (0, path_1.join)(this.layers0Path, 'nodes', child.path);
-            if (this.options.slpk) {
-                await this.writeQueue.enqueue({
-                    archiveKey: 'nodes/1/3dNodeIndexDocument.json.gz',
-                    writePromise: (0, file_utils_1.writeFileForSlpk)(childPath, JSON.stringify(child), '3dNodeIndexDocument.json')
-                });
-            }
-            else {
-                await this.writeQueue.enqueue({ writePromise: (0, file_utils_1.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();
     }
     /**
      * Write 3DSceneLayer https://github.com/Esri/i3s-spec/blob/master/docs/1.7/3DSceneLayer.cmn.md in file
@@ -301,29 +288,15 @@ class I3SConverter {
         if (this.options.slpk) {
             await this.writeQueue.enqueue({
                 archiveKey: '3dSceneLayer.json.gz',
-                writePromise: (0, file_utils_1.writeFileForSlpk)(this.layers0Path, JSON.stringify(this.layers0), '3dSceneLayer.json')
+                writePromise: () => (0, file_utils_1.writeFileForSlpk)(this.layers0Path, JSON.stringify(this.layers0), '3dSceneLayer.json')
             });
         }
         else {
             await this.writeQueue.enqueue({
-                writePromise: (0, file_utils_1.writeFile)(this.layers0Path, JSON.stringify(this.layers0))
+                writePromise: () => (0, file_utils_1.writeFile)(this.layers0Path, JSON.stringify(this.layers0))
             });
         }
     }
-    /**
-     * Write 3DNodeIndexDocument https://github.com/Esri/i3s-spec/blob/master/docs/1.7/3DNodeIndexDocument.cmn.md in file
-     */
-    async _writeNodeIndexDocument(root0, nodePath, rootPath) {
-        if (this.options.slpk) {
-            await this.writeQueue.enqueue({
-                archiveKey: `nodes/${nodePath}/3dNodeIndexDocument.json.gz`,
-                writePromise: (0, file_utils_1.writeFileForSlpk)(rootPath, JSON.stringify(root0), '3dNodeIndexDocument.json')
-            });
-        }
-        else {
-            await this.writeQueue.enqueue({ writePromise: (0, file_utils_1.writeFile)(rootPath, JSON.stringify(root0)) });
-        }
-    }
     /**
      * Pack files into *.slpk archive
      * @param tilesetPath - Path to save file
@@ -362,32 +335,26 @@ class I3SConverter {
     /**
      * Add child nodes recursively and write them to files
      * @param data - arguments
+     * @param data.parentNode - 3DNodeIndexDocument of parent node
      * @param data.sourceTiles - array of source child nodes
-     * @param data.parentNode - 3DNodeIndexDocument of parent node for processing child nodes
-     * @param data.parentId - id of parent node in node pages
      * @param data.level - level of node (distanse to root node in the tree)
      */
     async _addChildrenWithNeighborsAndWriteFile(data) {
-        const childNodes = [];
-        await this._addChildren({ ...data, childNodes });
-        await this._addNeighborsAndWriteFile(data.parentNode, childNodes);
+        await this._addChildren(data);
+        await data.parentNode.addNeighbors();
     }
     /**
      * Convert nested subtree of 3DTiles dataset
      * @param param0
+     * @param data.parentNode - 3DNodeIndexDocument of parent node
      * @param param0.sourceTile - source 3DTile data
-     * @param param0.parentNode - parent I3S node
-     * @param param0.childNodes - child I3S nodes
-     * @param param0.parentId - parent node ID
      * @param param0.level - tree level
      */
-    async convertNestedTileset({ sourceTile, parentNode, childNodes, parentId, level }) {
+    async convertNestedTileset({ parentNode, sourceTile, level }) {
         await this.sourceTileset._loadTile(sourceTile);
         await this._addChildren({
             parentNode,
             sourceTiles: sourceTile.children,
-            childNodes,
-            parentId,
             level: level + 1
         });
         await sourceTile.unloadContent();
@@ -395,92 +362,45 @@ class I3SConverter {
     /**
      * Convert 3DTiles tile to I3S node
      * @param param0
+     * @param param0.parentNode - 3DNodeIndexDocument of parent node
      * @param param0.sourceTile - source 3DTile data
-     * @param param0.parentNode - parent I3S node
-     * @param param0.childNodes - child I3S nodes
-     * @param param0.parentId - parent node ID
      * @param param0.level - tree level
      */
-    async convertNode({ sourceTile, parentNode, childNodes, parentId, level }) {
-        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: `../${child.path}`,
-                obb: child.obb,
-                mbs: child.mbs
-            });
-            childNodes.push(child);
-        }
+    async convertNode({ parentNode, sourceTile, level }) {
+        const childNodes = await this._createNode(parentNode, sourceTile, level);
+        await parentNode.addChildren(childNodes);
     }
     /**
      * Add child nodes recursively and write them to files
-     * @param data - arguments
-     * @param data.childNodes - array of target child nodes
-     * @param data.sourceTiles - array of source child nodes
-     * @param data.parentNode - 3DNodeIndexDocument of parent node for processing child nodes
-     * @param data.parentId - id of parent node in node pages
-     * @param data.level - level of node (distanse to root node in the tree)
+     * @param param0 - arguments
+     * @param param0.parentNode - 3DNodeIndexDocument of parent node
+     * @param param0.sourceTile - source 3DTile data
+     * @param param0.level - tree level
      */
     async _addChildren(data) {
-        const { childNodes, sourceTiles, parentNode, parentId, level } = data;
+        const { sourceTiles, parentNode, level } = data;
         if (this.options.maxDepth && level > this.options.maxDepth) {
             return;
         }
-        const promises = [];
         for (const sourceTile of sourceTiles) {
             if (sourceTile.type === 'json') {
-                promises.push(this.convertNestedTileset({ sourceTile, parentNode, childNodes, parentId, level }));
+                await this.convertNestedTileset({ parentNode, sourceTile, level });
             }
             else {
-                promises.push(this.convertNode({ sourceTile, parentNode, childNodes, parentId, level }));
+                await this.convertNode({ parentNode, sourceTile, level });
             }
-            await Promise.all(promises);
             if (sourceTile.id) {
                 console.log(sourceTile.id); // eslint-disable-line
             }
         }
     }
-    /**
-     * Add neightbors to 3DNodeIndexDocument and write it in a file
-     * @param parentNode - arguments
-     * @param childNodes - array of target child nodes
-     */
-    async _addNeighborsAndWriteFile(parentNode, childNodes) {
-        for (const node of childNodes) {
-            const childPath = (0, path_1.join)(this.layers0Path, 'nodes', node.path);
-            const nodePath = node.path;
-            delete node.path;
-            // Don't do large amount of "neightbors" to avoid big memory consumption
-            if (Number(parentNode?.children?.length) < 1000) {
-                for (const neighbor of parentNode.children || []) {
-                    // eslint-disable-next-line max-depth
-                    if (node.id === neighbor.id) {
-                        continue; // eslint-disable-line
-                    }
-                    if (node.neighbors) {
-                        node.neighbors.push({ ...neighbor });
-                    }
-                }
-            }
-            else {
-                // eslint-disable-next-line no-console, no-undef
-                console.warn(`Node ${node.id}: neighbors attribute is omited because of large number of neigbors`);
-                delete node.neighbors;
-            }
-            await this._writeNodeIndexDocument(node, nodePath, childPath);
-            node.neighbors = [];
-        }
-    }
     /**
      * Convert tile to one or more I3S nodes
-     * @param parentTile - parent 3DNodeIndexDocument
-     * @param sourceTile - source tile (3DTile)
-     * @param parentId - id of parent node in node pages
-     * @param level - level of node (distanse to root node in the tree)
+     * @param parentNode - 3DNodeIndexDocument of parent node
+     * @param sourceTile - source 3DTile data
+     * @param level - tree level
      */
-    async _createNode(parentTile, sourceTile, parentId, level) {
+    async _createNode(parentNode, sourceTile, level) {
         this._checkAddRefinementTypeForTile(sourceTile);
         await this._updateTilesetOptions();
         await this.sourceTileset._loadTile(sourceTile);
@@ -489,13 +409,15 @@ class I3SConverter {
         if (propertyTable && !this.layers0?.attributeStorageInfo?.length) {
             this._convertPropertyTableToNodeAttributes(propertyTable);
         }
-        const resourcesData = await this._convertResources(sourceTile, parentId, propertyTable);
+        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,
@@ -510,25 +432,26 @@ class I3SConverter {
             }
             const lodSelection = (0, lod_conversion_utils_1.convertGeometricErrorToScreenThreshold)(sourceTile, boundingVolumes);
             const maxScreenThresholdSQ = lodSelection.find((val) => val.metricType === 'maxScreenThresholdSQ') || { maxError: 0 };
-            const nodeInPage = this._updateNodeInNodePages(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 node_index_document_1.NodeIndexDocument.createNodeIndexDocument(parentNode, boundingVolumes, lodSelection, nodeInPage, resources);
+            const node = await new node_index_document_1.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 = (0, node_debug_1.validateNodeBoundingVolumes)(node);
+                this.boundingVolumeWarnings = (0, node_debug_1.validateNodeBoundingVolumes)(nodeData);
                 if (this.boundingVolumeWarnings && this.boundingVolumeWarnings.length) {
                     console.warn('Bounding Volume Warnings: ', ...this.boundingVolumeWarnings); //eslint-disable-line
                 }
             }
-            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;
@@ -538,14 +461,7 @@ class I3SConverter {
      * @param sourceTile - source tile (3DTile)
      * @param parentId - id of parent node in node pages
      * @param propertyTable - batch table from b3dm / feature properties from EXT_FEATURE_METADATA
-     * result.geometry - ArrayBuffer with geometry attributes
-     * result.compressedGeometry - ArrayBuffer with compressed (draco) geometry
-     * result.texture - texture image
-     * result.sharedResources - shared resource data object
-     * result.meshMaterial - PBR-like material object
-     * result.vertexCount - number of vertices in geometry
-     * result.attributes - feature attributes
-     * result.featureCount - number of features
+     * @returns - converted node resources
      */
     async _convertResources(sourceTile, parentId, propertyTable) {
         if (!this.isContentSupported(sourceTile)) {
@@ -556,7 +472,7 @@ class I3SConverter {
             halfSize: [],
             quaternion: []
         };
-        const resourcesData = await (0, geometry_converter_1.default)(sourceTile.content, () => this.nodePages.push({ index: 0, obb: draftObb }, parentId), propertyTable, this.featuresHashArray, this.layers0?.attributeStorageInfo, this.options.draco, this.generateBoundingVolumes, this.geoidHeightModel, this.workerSource);
+        const resourcesData = await (0, geometry_converter_1.default)(sourceTile.content, async () => (await this.nodePages.push({ index: 0, obb: draftObb }, parentId)).index, propertyTable, this.featuresHashArray, this.layers0?.attributeStorageInfo, this.options.draco, this.generateBoundingVolumes, this.options.mergeMaterials, this.geoidHeightModel, this.workerSource);
         return resourcesData;
     }
     /**
@@ -571,10 +487,11 @@ class I3SConverter {
      * @param resources.texture - texture image
      * @param resources.vertexCount - number of vertices in geometry
      * @param resources.featureCount - number of features
+     * @param resources.geometry - Uint8Array with geometry attributes
      * @return the node object in node pages
      */
-    _updateNodeInNodePages(maxScreenThresholdSQ, boundingVolumes, sourceTile, parentId, resources) {
-        const { meshMaterial, texture, vertexCount, featureCount, geometry } = resources;
+    async _updateNodeInNodePages(maxScreenThresholdSQ, boundingVolumes, sourceTile, parentId, resources) {
+        const { meshMaterial, texture, vertexCount, featureCount, geometry, hasUvRegions } = resources;
         const nodeInPage = {
             index: 0,
             lodThreshold: maxScreenThresholdSQ.maxError,
@@ -584,7 +501,7 @@ class I3SConverter {
         if (geometry && this.isContentSupported(sourceTile)) {
             nodeInPage.mesh = {
                 geometry: {
-                    definition: texture ? 0 : 1,
+                    definition: this.findOrCreateGeometryDefinition(Boolean(texture), hasUvRegions),
                     resource: 0
                 },
                 attribute: {
@@ -596,76 +513,30 @@ class I3SConverter {
             };
         }
         let nodeId = resources.nodeId;
-        if (nodeId) {
-            this.nodePages.updateAll(nodeId, nodeInPage);
-            const node = this.nodePages.getNodeById(nodeId);
-            this.nodePages.updateResourceInMesh(node);
+        let node;
+        if (!nodeId) {
+            node = await this.nodePages.push(nodeInPage, parentId);
         }
         else {
-            nodeId = this.nodePages.push(nodeInPage, parentId);
+            node = await this.nodePages.getNodeById(nodeId);
         }
+        node_pages_1.default.updateAll(node, nodeInPage);
         if (meshMaterial) {
-            this.nodePages.updateMaterialByNodeId(nodeId, this._findOrCreateMaterial(meshMaterial));
+            node_pages_1.default.updateMaterialByNodeId(node, this._findOrCreateMaterial(meshMaterial));
         }
         if (texture) {
             const texelCountHint = texture.image.height * texture.image.width;
-            this.nodePages.updateTexelCountHintByNodeId(nodeId, texelCountHint);
+            node_pages_1.default.updateTexelCountHintByNodeId(node, texelCountHint);
         }
         if (vertexCount) {
             this.vertexCounter += vertexCount;
-            this.nodePages.updateVertexCountByNodeId(nodeId, vertexCount);
+            node_pages_1.default.updateVertexCountByNodeId(node, vertexCount);
         }
-        this.nodePages.updateNodeAttributeByNodeId(nodeId);
+        node_pages_1.default.updateNodeAttributeByNodeId(node);
         if (featureCount) {
-            this.nodePages.updateFeatureCountByNodeId(nodeId, featureCount);
-        }
-        return this.nodePages.getNodeById(nodeId);
-    }
-    /**
-     * Create a new node page object in node pages
-     * @param parentNode - 3DNodeIndexDocument https://github.com/Esri/i3s-spec/blob/master/docs/1.7/3DNodeIndexDocument.cmn.md object of the parent node
-     * @param boundingVolumes - Bounding volumes
-     * @param lodSelection - Level of Details (LOD) metrics
-     * @param nodeInPage - corresponding node object in a node page
-     * @param resources - the node resources data
-     * @param resources.texture - texture image
-     * @param resources.attributes - feature attributes
-     * @return 3DNodeIndexDocument https://github.com/Esri/i3s-spec/blob/master/docs/1.7/3DNodeIndexDocument.cmn.md object
-     */
-    _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: `../${parentNode.id}`,
-                mbs: parentNode.mbs,
-                obb: parentNode.obb
-            },
-            children: [],
-            neighbors: []
-        };
-        const node = (0, json_map_transform_1.default)(nodeData, (0, node_1.NODE)());
-        if (nodeInPage.mesh) {
-            node.geometryData = [{ href: './geometries/0' }];
-            node.sharedResource = { href: './shared' };
-            if (texture) {
-                node.textureData = [{ href: './textures/0' }, { href: './textures/1' }];
-            }
-            if (attributes && attributes.length && this.layers0?.attributeStorageInfo?.length) {
-                node.attributeData = [];
-                for (let index = 0; index < attributes.length; index++) {
-                    const folderName = this.layers0.attributeStorageInfo[index].key;
-                    node.attributeData.push({ href: `./attributes/${folderName}/0` });
-                }
-            }
+            node_pages_1.default.updateFeatureCountByNodeId(node, featureCount);
         }
+        this.nodePages.saveNode(node);
         return node;
     }
     /**
@@ -699,13 +570,13 @@ class I3SConverter {
             const slpkGeometryPath = (0, path_1.join)(childPath, 'geometries');
             await this.writeQueue.enqueue({
                 archiveKey: `${slpkChildPath}/geometries/0.bin.gz`,
-                writePromise: (0, file_utils_1.writeFileForSlpk)(slpkGeometryPath, geometryBuffer, '0.bin')
+                writePromise: () => (0, file_utils_1.writeFileForSlpk)(slpkGeometryPath, geometryBuffer, '0.bin')
             });
         }
         else {
             const geometryPath = (0, path_1.join)(childPath, 'geometries/0/');
             await this.writeQueue.enqueue({
-                writePromise: (0, file_utils_1.writeFile)(geometryPath, geometryBuffer, 'index.bin')
+                writePromise: () => (0, file_utils_1.writeFile)(geometryPath, geometryBuffer, 'index.bin')
             });
         }
         if (this.options.draco) {
@@ -713,13 +584,13 @@ class I3SConverter {
                 const slpkCompressedGeometryPath = (0, path_1.join)(childPath, 'geometries');
                 await this.writeQueue.enqueue({
                     archiveKey: `${slpkChildPath}/geometries/1.bin.gz`,
-                    writePromise: (0, file_utils_1.writeFileForSlpk)(slpkCompressedGeometryPath, compressedGeometry, '1.bin')
+                    writePromise: () => (0, file_utils_1.writeFileForSlpk)(slpkCompressedGeometryPath, compressedGeometry, '1.bin')
                 });
             }
             else {
                 const compressedGeometryPath = (0, path_1.join)(childPath, 'geometries/1/');
                 await this.writeQueue.enqueue({
-                    writePromise: (0, file_utils_1.writeFile)(compressedGeometryPath, compressedGeometry, 'index.bin')
+                    writePromise: () => (0, file_utils_1.writeFile)(compressedGeometryPath, compressedGeometry, 'index.bin')
                 });
             }
         }
@@ -742,12 +613,12 @@ class I3SConverter {
             const slpkSharedPath = (0, path_1.join)(childPath, 'shared');
             await this.writeQueue.enqueue({
                 archiveKey: `${slpkChildPath}/shared/sharedResource.json.gz`,
-                writePromise: (0, file_utils_1.writeFileForSlpk)(slpkSharedPath, sharedDataStr, 'sharedResource.json')
+                writePromise: () => (0, file_utils_1.writeFileForSlpk)(slpkSharedPath, sharedDataStr, 'sharedResource.json')
             });
         }
         else {
             const sharedPath = (0, path_1.join)(childPath, 'shared/');
-            await this.writeQueue.enqueue({ writePromise: (0, file_utils_1.writeFile)(sharedPath, sharedDataStr) });
+            await this.writeQueue.enqueue({ writePromise: () => (0, file_utils_1.writeFile)(sharedPath, sharedDataStr) });
         }
     }
     /**
@@ -793,6 +664,7 @@ class I3SConverter {
             }
             if (!this.layers0.textureSetDefinitions.length) {
                 this.layers0.textureSetDefinitions.push({ formats });
+                this.layers0.textureSetDefinitions.push({ formats, atlas: true });
             }
         }
     }
@@ -810,13 +682,13 @@ class I3SConverter {
             const compress = false;
             await this.writeQueue.enqueue({
                 archiveKey: `${slpkChildPath}/textures/${name}.${format}`,
-                writePromise: (0, file_utils_1.writeFileForSlpk)(slpkTexturePath, textureData, `${name}.${format}`, compress)
+                writePromise: () => (0, file_utils_1.writeFileForSlpk)(slpkTexturePath, textureData, `${name}.${format}`, compress)
             });
         }
         else {
             const texturePath = (0, path_1.join)(childPath, `textures/${name}/`);
             await this.writeQueue.enqueue({
-                writePromise: (0, file_utils_1.writeFile)(texturePath, textureData, `index.${format}`)
+                writePromise: () => (0, file_utils_1.writeFile)(texturePath, textureData, `index.${format}`)
             });
         }
     }
@@ -835,13 +707,13 @@ class I3SConverter {
                     const slpkAttributesPath = (0, path_1.join)(childPath, 'attributes', folderName);
                     await this.writeQueue.enqueue({
                         archiveKey: `${slpkChildPath}/attributes/${folderName}.bin.gz`,
-                        writePromise: (0, file_utils_1.writeFileForSlpk)(slpkAttributesPath, fileBuffer, '0.bin')
+                        writePromise: () => (0, file_utils_1.writeFileForSlpk)(slpkAttributesPath, fileBuffer, '0.bin')
                     });
                 }
                 else {
                     const attributesPath = (0, path_1.join)(childPath, `attributes/${folderName}/0`);
                     await this.writeQueue.enqueue({
-                        writePromise: (0, file_utils_1.writeFile)(attributesPath, fileBuffer, 'index.bin')
+                        writePromise: () => (0, file_utils_1.writeFile)(attributesPath, fileBuffer, 'index.bin')
                     });
                 }
             }
@@ -871,12 +743,29 @@ class I3SConverter {
     _findOrCreateMaterial(material) {
         const hash = (0, md5_1.default)(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;
     }
+    /**
+     * Get unique geometry configuration index
+     * In the end of conversion configurations will be transformed to geometryDefinitions array
+     * @param hasTexture
+     * @param hasUvRegions
+     * @returns
+     */
+    findOrCreateGeometryDefinition(hasTexture, hasUvRegions) {
+        const geometryConfig = { hasTexture, hasUvRegions };
+        const hash = (0, md5_1.default)(JSON.stringify(geometryConfig));
+        if (this.geometryMap.has(hash)) {
+            return this.geometryMap.get(hash) || 0;
+        }
+        const newGeometryId = this.geometryConfigs.push(geometryConfig) - 1;
+        this.geometryMap.set(hash, newGeometryId);
+        return newGeometryId;
+    }
     /**
      * Do conversion of 3DTiles property table to I3s node attributes.
      * @param propertyTable - Table with layer meta data.