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

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

@@ -1,5 +1,6 @@
 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';
@@ -9,8 +10,8 @@ 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
+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, { getPropertyTable } from './helpers/geometry-converter';
@@ -19,9 +20,10 @@ 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';
 import { ImageWriter } from '@loaders.gl/images';
 import { getWorkerURL, WorkerFarm } from '@loaders.gl/worker-utils';
@@ -30,6 +32,7 @@ import WriteQueue from '../lib/utils/write-queue';
 import { I3SAttributesWorker } from '../i3s-attributes-worker';
 import { BROWSER_ERROR_MESSAGE } from '../constants';
 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;
@@ -45,6 +48,8 @@ export default class I3SConverter {
     _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);
@@ -61,11 +66,14 @@ export default class I3SConverter {
     _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 = [];
@@ -77,6 +85,7 @@ export default class I3SConverter {
     this.generateTextures = false;
     this.generateBoundingVolumes = false;
     this.layersHasTexture = false;
+    this.compressList = null;
   }
 
   async convert(options) {
@@ -92,12 +101,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,
@@ -106,8 +117,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);
@@ -176,23 +190,31 @@ export default class I3SConverter {
     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);
   }
@@ -223,78 +245,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) {
-        await this.writeQueue.enqueue({
-          archiveKey: 'nodes/1/3dNodeIndexDocument.json.gz',
-          writePromise: writeFileForSlpk(childPath, JSON.stringify(child), '3dNodeIndexDocument.json')
-        });
-      } else {
-        await 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) {
       await this.writeQueue.enqueue({
         archiveKey: '3dSceneLayer.json.gz',
-        writePromise: writeFileForSlpk(this.layers0Path, JSON.stringify(this.layers0), '3dSceneLayer.json')
-      });
-    } else {
-      await this.writeQueue.enqueue({
-        writePromise: writeFile(this.layers0Path, JSON.stringify(this.layers0))
-      });
-    }
-  }
-
-  async _writeNodeIndexDocument(root0, nodePath, rootPath) {
-    if (this.options.slpk) {
-      await this.writeQueue.enqueue({
-        archiveKey: "nodes/".concat(nodePath, "/3dNodeIndexDocument.json.gz"),
-        writePromise: writeFileForSlpk(rootPath, JSON.stringify(root0), '3dNodeIndexDocument.json')
+        writePromise: () => writeFileForSlpk(this.layers0Path, JSON.stringify(this.layers0), '3dSceneLayer.json')
       });
     } else {
       await this.writeQueue.enqueue({
-        writePromise: writeFile(rootPath, JSON.stringify(root0))
+        writePromise: () => writeFile(this.layers0Path, JSON.stringify(this.layers0))
       });
     }
   }
@@ -313,28 +291,20 @@ export default class I3SConverter {
   }
 
   async _addChildrenWithNeighborsAndWriteFile(data) {
-    const childNodes = [];
-    await this._addChildren({
-      ...data,
-      childNodes
-    });
-    await this._addNeighborsAndWriteFile(data.parentNode, childNodes);
+    await this._addChildren(data);
+    await data.parentNode.addNeighbors();
   }
 
   async convertNestedTileset(_ref) {
     let {
-      sourceTile,
       parentNode,
-      childNodes,
-      parentId,
+      sourceTile,
       level
     } = _ref;
     await this.sourceTileset._loadTile(sourceTile);
     await this._addChildren({
       parentNode,
       sourceTiles: sourceTile.children,
-      childNodes,
-      parentId,
       level: level + 1
     });
     await sourceTile.unloadContent();
@@ -342,91 +312,44 @@ export default class I3SConverter {
 
   async convertNode(_ref2) {
     let {
-      sourceTile,
       parentNode,
-      childNodes,
-      parentId,
+      sourceTile,
       level
     } = _ref2;
-    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);
-    }
+    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;
     }
-    const promises = [];
     for (const sourceTile of sourceTiles) {
       if (sourceTile.type === 'json') {
-        promises.push(this.convertNestedTileset({
-          sourceTile,
+        await this.convertNestedTileset({
           parentNode,
-          childNodes,
-          parentId,
+          sourceTile,
           level
-        }));
+        });
       } else {
-        promises.push(this.convertNode({
-          sourceTile,
+        await this.convertNode({
           parentNode,
-          childNodes,
-          parentId,
+          sourceTile,
           level
-        }));
+        });
       }
-      await Promise.all(promises);
       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) {
+  async _createNode(parentNode, sourceTile, level) {
     var _this$layers, _this$layers$attribut;
     this._checkAddRefinementTypeForTile(sourceTile);
     await this._updateTilesetOptions();
@@ -436,13 +359,15 @@ export default class I3SConverter {
     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, 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,
@@ -459,26 +384,27 @@ export default class I3SConverter {
       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 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;
@@ -494,20 +420,21 @@ export default class I3SConverter {
       halfSize: [],
       quaternion: []
     };
-    const resourcesData = await convertB3dmToI3sGeometry(sourceTile.content, () => this.nodePages.push({
+    const resourcesData = await convertB3dmToI3sGeometry(sourceTile.content, async () => (await this.nodePages.push({
       index: 0,
       obb: draftObb
-    }, parentId), propertyTable, 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);
+    }, 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;
   }
 
-  _updateNodeInNodePages(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,
@@ -518,7 +445,7 @@ export default class I3SConverter {
     if (geometry && this.isContentSupported(sourceTile)) {
       nodeInPage.mesh = {
         geometry: {
-          definition: texture ? 0 : 1,
+          definition: this.findOrCreateGeometryDefinition(Boolean(texture), hasUvRegions),
           resource: 0
         },
         attribute: {
@@ -530,79 +457,29 @@ export default 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);
     }
+    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);
-    }
-    return this.nodePages.getNodeById(nodeId);
-  }
-
-  _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")
-          });
-        }
-      }
+      NodePages.updateFeatureCountByNodeId(node, featureCount);
     }
+    this.nodePages.saveNode(node);
     return node;
   }
 
@@ -627,12 +504,12 @@ export default class I3SConverter {
       const slpkGeometryPath = join(childPath, 'geometries');
       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/');
       await this.writeQueue.enqueue({
-        writePromise: writeFile(geometryPath, geometryBuffer, 'index.bin')
+        writePromise: () => writeFile(geometryPath, geometryBuffer, 'index.bin')
       });
     }
     if (this.options.draco) {
@@ -640,12 +517,12 @@ export default class I3SConverter {
         const slpkCompressedGeometryPath = join(childPath, 'geometries');
         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/');
         await this.writeQueue.enqueue({
-          writePromise: writeFile(compressedGeometryPath, compressedGeometry, 'index.bin')
+          writePromise: () => writeFile(compressedGeometryPath, compressedGeometry, 'index.bin')
         });
       }
     }
@@ -662,12 +539,12 @@ export default class I3SConverter {
       const slpkSharedPath = join(childPath, 'shared');
       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/');
       await this.writeQueue.enqueue({
-        writePromise: writeFile(sharedPath, sharedDataStr)
+        writePromise: () => writeFile(sharedPath, sharedDataStr)
       });
     }
   }
@@ -727,6 +604,10 @@ export default class I3SConverter {
         this.layers0.textureSetDefinitions.push({
           formats
         });
+        this.layers0.textureSetDefinitions.push({
+          formats,
+          atlas: true
+        });
       }
     }
   }
@@ -737,22 +618,22 @@ export default class I3SConverter {
       const compress = false;
       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, "/"));
       await this.writeQueue.enqueue({
-        writePromise: writeFile(texturePath, textureData, "index.".concat(format))
+        writePromise: () => writeFile(texturePath, textureData, "index.".concat(format))
       });
     }
   }
 
   async _writeAttributes() {
-    var _this$layers4, _this$layers4$attribu;
+    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$layers4 = this.layers0) !== null && _this$layers4 !== void 0 && (_this$layers4$attribu = _this$layers4.attributeStorageInfo) !== null && _this$layers4$attribu !== void 0 && _this$layers4$attribu.length) {
+    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]);
@@ -760,12 +641,12 @@ export default class I3SConverter {
           const slpkAttributesPath = join(childPath, 'attributes', folderName);
           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"));
           await this.writeQueue.enqueue({
-            writePromise: writeFile(attributesPath, fileBuffer, 'index.bin')
+            writePromise: () => writeFile(attributesPath, fileBuffer, 'index.bin')
           });
         }
       }
@@ -788,13 +669,27 @@ 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;
   }
 
+  findOrCreateGeometryDefinition(hasTexture, hasUvRegions) {
+    const geometryConfig = {
+      hasTexture,
+      hasUvRegions
+    };
+    const hash = md5(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;
+  }
+
   _convertPropertyTableToNodeAttributes(propertyTable) {
     let attributeIndex = 0;
     const propertyTableWithObjectId = {