@loaders.gl/tile-converter 4.1.0-alpha.9 → 4.2.0-alpha.1

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

@@ -9,7 +9,7 @@ import transform from 'json-map-transform';
 import md5 from 'md5';
 import NodePages from "./helpers/node-pages.js";
 import { writeFile, removeDir, writeFileForSlpk, removeFile } from "../lib/utils/file-utils.js";
-import { compressFileWithGzip, compressWithChildProcess } from "../lib/utils/compress-util.js";
+import { compressFileWithGzip } from "../lib/utils/compress-util.js";
 import { calculateFilesSize, timeConverter } from "../lib/utils/statistic-utills.js";
 import convertB3dmToI3sGeometry, { getPropertyTable } from "./helpers/geometry-converter.js";
 import { createBoundingVolumes, convertBoundingVolumeToI3SFullExtent } from "./helpers/coordinate-converter.js";
@@ -21,9 +21,8 @@ import { GEOMETRY_DEFINITION as geometryDefinitionTemlate } from "./json-templat
 import { SHARED_RESOURCES as sharedResourcesTemplate } from "./json-templates/shared-resources.js";
 import { validateNodeBoundingVolumes } from "./helpers/node-debug.js";
 import { KTX2BasisWriterWorker } from '@loaders.gl/textures';
-import { FileHandleFile } from '@loaders.gl/loader-utils';
 import { ImageWriter } from '@loaders.gl/images';
-import { GLTFPrimitiveModeString } from "./types.js";
+import { GLTFPrimitiveModeString, ResourceType } from "./types.js";
 import { WorkerFarm } from '@loaders.gl/worker-utils';
 import WriteQueue from "../lib/utils/write-queue.js";
 import { BROWSER_ERROR_MESSAGE } from "../constants.js";
@@ -35,7 +34,8 @@ import { createBoundingVolume } from '@loaders.gl/tiles';
 import { traverseDatasetWith } from "./helpers/tileset-traversal.js";
 import { analyzeTileContent, mergePreprocessData } from "./helpers/preprocess-3d-tiles.js";
 import { Progress } from "./helpers/progress.js";
-import { addOneFile, composeHashFile } from '@loaders.gl/zip';
+import { composeHashFile, createZip } from '@loaders.gl/zip';
+import { ConversionDump } from "../lib/utils/conversion-dump.js";
 const ION_DEFAULT_TOKEN = (_process$env = process.env) === null || _process$env === void 0 ? void 0 : _process$env.IonToken;
 const HARDCODED_NODES_PER_PAGE = 64;
 const _3D_TILES = '3DTILES';
@@ -82,13 +82,14 @@ export default class I3SConverter {
     this.generateBoundingVolumes = void 0;
     this.layersHasTexture = void 0;
     this.workerSource = {};
-    this.writeQueue = new WriteQueue();
+    this.writeQueue = new WriteQueue(new ConversionDump());
     this.compressList = null;
     this.preprocessData = {
       meshTopologyTypes: new Set(),
       metadataClasses: new Set()
     };
     this.progresses = {};
+    this.conversionDump = void 0;
     this.attributeMetadataInfo = new AttributeMetadataInfo();
     this.nodePages = new NodePages(writeFile, HARDCODED_NODES_PER_PAGE, this);
     this.options = {};
@@ -109,6 +110,7 @@ export default class I3SConverter {
     this.generateBoundingVolumes = false;
     this.layersHasTexture = false;
     this.compressList = null;
+    this.conversionDump = new ConversionDump();
   }
   async convert(options) {
     if (isBrowser) {
@@ -136,6 +138,8 @@ export default class I3SConverter {
       analyze = false
     } = options;
     this.options = {
+      outputPath,
+      tilesetName,
       maxDepth,
       slpk,
       sevenZipExe,
@@ -154,7 +158,7 @@ export default class I3SConverter {
     this.Loader = inputUrl.indexOf(CESIUM_DATASET_PREFIX) !== -1 ? CesiumIonLoader : Tiles3DLoader;
     this.generateTextures = Boolean(generateTextures);
     this.generateBoundingVolumes = Boolean(generateBoundingVolumes);
-    this.writeQueue = new WriteQueue();
+    this.writeQueue = new WriteQueue(this.conversionDump);
     this.writeQueue.startListening();
     console.log('Loading egm file...');
     this.geoidHeightModel = await load(egmFilePath, PGMLoader);
@@ -274,12 +278,34 @@ export default class I3SConverter {
   async _createAndSaveTileset(outputPath, tilesetName) {
     var _this$sourceTileset, _this$sourceTileset$r, _this$sourceTileset$r2;
     const tilesetPath = join(`${outputPath}`, `${tilesetName}`);
+    await this.conversionDump.createDump(this.options);
+    if (this.conversionDump.restored && this.options.inquirer) {
+      const result = await this.options.inquirer.prompt([{
+        name: 'resumeConversion',
+        type: 'confirm',
+        message: 'Dump file of the previous conversion exists, do you want to resume that conversion?'
+      }]);
+      if (!result.resumeConversion) {
+        this.conversionDump.reset();
+      }
+    }
+    this.layers0Path = join(tilesetPath, 'SceneServer', 'layers', '0');
+    const removePath = this.conversionDump.restored ? join(this.layers0Path, 'nodepages') : tilesetPath;
     try {
-      await removeDir(tilesetPath);
+      await removeDir(removePath);
     } catch (e) {}
-    this.layers0Path = join(tilesetPath, 'SceneServer', 'layers', '0');
+    if (this.conversionDump.restored && this.conversionDump.attributeMetadataInfo) {
+      this.attributeMetadataInfo.fromObject(this.conversionDump.attributeMetadataInfo);
+    }
     this.materialDefinitions = [];
     this.materialMap = new Map();
+    if (this.conversionDump.restored && this.conversionDump.materialDefinitions) {
+      for (let i = 0; i < this.conversionDump.materialDefinitions.length; i++) {
+        const hash = md5(JSON.stringify(this.conversionDump.materialDefinitions[i]));
+        this.materialMap.set(hash, i);
+      }
+      this.materialDefinitions = this.conversionDump.materialDefinitions;
+    }
     const sourceRootTile = this.sourceTileset.root;
     const sourceBoundingVolume = createBoundingVolume(sourceRootTile.boundingVolume, new Matrix4(sourceRootTile.transform), null);
     this._formLayers0(tilesetName, sourceBoundingVolume, (_this$sourceTileset = this.sourceTileset) === null || _this$sourceTileset === void 0 ? void 0 : (_this$sourceTileset$r = _this$sourceTileset.root) === null || _this$sourceTileset$r === void 0 ? void 0 : (_this$sourceTileset$r2 = _this$sourceTileset$r.boundingVolume) === null || _this$sourceTileset$r2 === void 0 ? void 0 : _this$sourceTileset$r2.region);
@@ -304,6 +330,9 @@ export default class I3SConverter {
     if (this.attributeMetadataInfo.attributeStorageInfo.length) {
       this.layers0.layerType = _3D_OBJECT_LAYER_TYPE;
     }
+    if (this.conversionDump.restored && this.conversionDump.textureSetDefinitions) {
+      this.layers0.textureSetDefinitions = this.conversionDump.textureSetDefinitions;
+    }
     this.layers0.materialDefinitions = this.materialDefinitions;
     this.layers0.geometryDefinitions = transform(this.geometryConfigs.map(config => ({
       geometryConfig: {
@@ -365,12 +394,14 @@ export default class I3SConverter {
     }
   }
   async _createSlpk(tilesetPath) {
+    await this.conversionDump.deleteDumpFile();
     if (this.options.slpk) {
       const slpkTilesetPath = join(tilesetPath, 'SceneServer', 'layers', '0');
       const slpkFileName = `${tilesetPath}.slpk`;
-      await compressWithChildProcess(slpkTilesetPath, slpkFileName, 0, '.', this.options.sevenZipExe);
-      const hashTable = await composeHashFile(new FileHandleFile(slpkFileName));
-      await addOneFile(slpkFileName, hashTable, '@specialIndexFileHASH128@');
+      await createZip(slpkTilesetPath, slpkFileName, async fileList => ({
+        path: '@specialIndexFileHASH128@',
+        file: await composeHashFile(fileList)
+      }));
       try {
         await removeDir(tilesetPath);
       } catch (e) {}
@@ -399,7 +430,13 @@ export default class I3SConverter {
       transformationMatrix = transformationMatrix.multiplyRight(sourceTile.transform);
     }
     const parentNode = parentNodes[0];
-    const childNodes = await this._createNode(parentNode, sourceTile, transformationMatrix);
+    const restoreResult = await this._restoreNode(parentNode, sourceTile, transformationMatrix);
+    let childNodes;
+    if (restoreResult === null) {
+      childNodes = await this._createNode(parentNode, sourceTile, transformationMatrix);
+    } else {
+      childNodes = restoreResult;
+    }
     await parentNode.addChildren(childNodes);
     const newTraversalProps = {
       transform: transformationMatrix,
@@ -412,8 +449,9 @@ export default class I3SConverter {
       if (timeRemainingStringBasedOnCount) {
         timeRemainingString = `${timeRemainingStringBasedOnCount} left`;
       }
-      let percentString = this.progresses[PROGRESS_PHASE1_COUNT].getPercentString();
-      console.log(`[converted ${percentString}%, ${timeRemainingString}]: ${sourceTile.id}`);
+      const percentString = this.progresses[PROGRESS_PHASE1_COUNT].getPercentString();
+      const progressString = percentString ? ` ${percentString}%, ${timeRemainingString}` : '';
+      console.log(`[converted${progressString}]: ${sourceTile.id}`);
     }
     return newTraversalProps;
   }
@@ -427,6 +465,57 @@ export default class I3SConverter {
       await node.save();
     }
   }
+  async _generateNodeIndexDocument(boundingVolumes, resources, parentNode, sourceTile, isDumped) {
+    this.layersHasTexture = this.layersHasTexture || Boolean('texture' in resources && resources.texture || 'texelCountHint' in resources && resources.texelCountHint);
+    if (this.generateBoundingVolumes && resources.boundingVolumes) {
+      boundingVolumes = resources.boundingVolumes;
+    }
+    const lodSelection = convertGeometricErrorToScreenThreshold(sourceTile, boundingVolumes);
+    const maxScreenThresholdSQ = lodSelection.find(val => val.metricType === 'maxScreenThresholdSQ') || {
+      maxError: 0
+    };
+    if (isDumped) {
+      const draftObb = {
+        center: [],
+        halfSize: [],
+        quaternion: []
+      };
+      await this.nodePages.push({
+        index: 0,
+        obb: draftObb
+      }, parentNode.inPageId);
+    }
+    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);
+    return {
+      node,
+      nodeInPage,
+      nodeData
+    };
+  }
+  async _restoreNode(parentNode, sourceTile, transformationMatrix) {
+    this._checkAddRefinementTypeForTile(sourceTile);
+    await this._updateTilesetOptions();
+    if (this.conversionDump.restored && sourceTile.id && this.conversionDump.isFileConversionComplete(sourceTile.id)) {
+      const sourceBoundingVolume = createBoundingVolume(sourceTile.boundingVolume, transformationMatrix, null);
+      let boundingVolumes = createBoundingVolumes(sourceBoundingVolume, this.geoidHeightModel);
+      const nodes = [];
+      for (const convertedNode of this.conversionDump.tilesConverted[sourceTile.id].nodes) {
+        const {
+          node
+        } = await this._generateNodeIndexDocument(boundingVolumes, {
+          ...convertedNode.dumpMetadata,
+          nodeId: convertedNode.nodeId
+        }, parentNode, sourceTile, true);
+        nodes.push(node);
+      }
+      return nodes;
+    } else if (this.conversionDump.restored && sourceTile.id) {
+      this.conversionDump.clearDumpRecord(sourceTile.id);
+    }
+    return null;
+  }
   async _createNode(parentNode, sourceTile, transformationMatrix) {
     this._checkAddRefinementTypeForTile(sourceTile);
     await this._updateTilesetOptions();
@@ -440,6 +529,11 @@ export default class I3SConverter {
     let boundingVolumes = createBoundingVolumes(sourceBoundingVolume, this.geoidHeightModel);
     const propertyTable = getPropertyTable(tileContent, this.options.metadataClass);
     this.createAttributeStorageInfo(tileContent, propertyTable);
+    this.conversionDump.attributeMetadataInfo = {
+      attributeStorageInfo: this.attributeMetadataInfo.attributeStorageInfo,
+      fields: this.attributeMetadataInfo.fields,
+      popupInfo: this.attributeMetadataInfo.popupInfo
+    };
     const resourcesData = await this._convertResources(sourceTile, transformationMatrix, sourceBoundingVolume, tileContent, parentNode.inPageId, propertyTable);
     const nodes = [];
     const nodeIds = [];
@@ -457,20 +551,29 @@ export default class I3SConverter {
       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 = 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);
+      const {
+        node,
+        nodeInPage,
+        nodeData
+      } = await this._generateNodeIndexDocument(boundingVolumes, resources, parentNode, sourceTile, false);
       nodes.push(node);
       if (nodeInPage.mesh) {
-        await this._writeResources(resources, node.id);
+        if (sourceTile.id) {
+          var _resources$attributes;
+          const dumpMetadata = {
+            boundingVolumes: resources.boundingVolumes,
+            attributesCount: (_resources$attributes = resources.attributes) === null || _resources$attributes === void 0 ? void 0 : _resources$attributes.length,
+            featureCount: resources.featureCount,
+            geometry: Boolean(resources.geometry),
+            hasUvRegions: resources.hasUvRegions,
+            materialId: nodeInPage.mesh.material.definition,
+            texelCountHint: nodeInPage.mesh.material.texelCountHint,
+            vertexCount: resources.vertexCount
+          };
+          this.conversionDump.setMaterialsDefinitions(this.materialDefinitions);
+          await this.conversionDump.addNode(sourceTile.id, nodeInPage.index, dumpMetadata);
+        }
+        await this._writeResources(resources, node.id, sourceTile);
       }
       if (this.validate) {
         this.boundingVolumeWarnings = validateNodeBoundingVolumes(nodeData);
@@ -500,8 +603,6 @@ export default class I3SConverter {
   }
   async _updateNodeInNodePages(maxScreenThresholdSQ, boundingVolumes, sourceTile, parentId, resources) {
     const {
-      meshMaterial,
-      texture,
       vertexCount,
       featureCount,
       geometry,
@@ -516,7 +617,7 @@ export default class I3SConverter {
     if (geometry && this.isContentSupported(sourceTile)) {
       nodeInPage.mesh = {
         geometry: {
-          definition: this.findOrCreateGeometryDefinition(Boolean(texture), hasUvRegions),
+          definition: this.findOrCreateGeometryDefinition(Boolean('texture' in resources && resources.texture || 'texelCountHint' in resources && resources.texelCountHint), hasUvRegions),
           resource: 0
         },
         attribute: {
@@ -527,7 +628,7 @@ export default class I3SConverter {
         }
       };
     }
-    let nodeId = resources.nodeId;
+    let nodeId = 'nodeId' in resources ? resources.nodeId : undefined;
     let node;
     if (!nodeId) {
       node = await this.nodePages.push(nodeInPage, parentId);
@@ -538,12 +639,16 @@ export default class I3SConverter {
       console.log(`[warning]: node ${node.index} is created with empty content`);
     }
     NodePages.updateAll(node, nodeInPage);
-    if (meshMaterial) {
-      NodePages.updateMaterialByNodeId(node, this._findOrCreateMaterial(meshMaterial));
+    if ('meshMaterial' in resources && resources.meshMaterial) {
+      NodePages.updateMaterialByNodeId(node, this._findOrCreateMaterial(resources.meshMaterial));
+    } else if ('materialId' in resources && resources.materialId !== null) {
+      NodePages.updateMaterialByNodeId(node, resources.materialId);
     }
-    if (texture) {
-      const texelCountHint = texture.image.height * texture.image.width;
+    if ('texture' in resources && resources.texture) {
+      const texelCountHint = resources.texture.image.height * resources.texture.image.width;
       NodePages.updateTexelCountHintByNodeId(node, texelCountHint);
+    } else if ('texelCountHint' in resources && resources.texelCountHint) {
+      NodePages.updateTexelCountHintByNodeId(node, resources.texelCountHint);
     }
     if (vertexCount) {
       this.vertexCounter += vertexCount;
@@ -556,7 +661,7 @@ export default class I3SConverter {
     this.nodePages.saveNode(node);
     return node;
   }
-  async _writeResources(resources, nodePath) {
+  async _writeResources(resources, nodePath, sourceTile) {
     const {
       geometry: geometryBuffer,
       compressedGeometry,
@@ -566,60 +671,81 @@ export default class I3SConverter {
     } = resources;
     const childPath = join(this.layers0Path, 'nodes', nodePath);
     const slpkChildPath = join('nodes', nodePath);
-    await this._writeGeometries(geometryBuffer, compressedGeometry, childPath, slpkChildPath);
-    await this._writeShared(sharedResources, childPath, slpkChildPath, nodePath);
-    await this._writeTexture(texture, childPath, slpkChildPath);
-    await this._writeAttributes(attributes, childPath, slpkChildPath);
+    await this._writeGeometries(geometryBuffer, compressedGeometry, childPath, slpkChildPath, sourceTile.id || '', parseInt(nodePath));
+    await this._writeShared(sharedResources, childPath, slpkChildPath, nodePath, sourceTile.id || '', parseInt(nodePath));
+    await this._writeTexture(texture, childPath, slpkChildPath, sourceTile.id || '', parseInt(nodePath));
+    await this._writeAttributes(attributes, childPath, slpkChildPath, sourceTile.id || '', parseInt(nodePath));
   }
-  async _writeGeometries(geometryBuffer, compressedGeometry, childPath, slpkChildPath) {
+  async _writeGeometries(geometryBuffer, compressedGeometry, childPath, slpkChildPath, sourceId, nodeId) {
+    this.conversionDump.updateDoneStatus(sourceId, nodeId, ResourceType.GEOMETRY, false);
     if (this.options.slpk) {
       const slpkGeometryPath = join(childPath, 'geometries');
       await this.writeQueue.enqueue({
         archiveKey: `${slpkChildPath}/geometries/0.bin.gz`,
+        sourceId,
+        outputId: nodeId,
+        resourceType: ResourceType.GEOMETRY,
         writePromise: () => writeFileForSlpk(slpkGeometryPath, geometryBuffer, '0.bin')
       });
     } else {
       const geometryPath = join(childPath, 'geometries/0/');
       await this.writeQueue.enqueue({
+        sourceId,
+        outputId: nodeId,
+        resourceType: ResourceType.GEOMETRY,
         writePromise: () => writeFile(geometryPath, geometryBuffer, 'index.bin')
       });
     }
     if (this.options.draco) {
+      this.conversionDump.updateDoneStatus(sourceId, nodeId, ResourceType.DRACO_GEOMETRY, false);
       if (this.options.slpk) {
         const slpkCompressedGeometryPath = join(childPath, 'geometries');
         await this.writeQueue.enqueue({
           archiveKey: `${slpkChildPath}/geometries/1.bin.gz`,
+          sourceId,
+          outputId: nodeId,
+          resourceType: ResourceType.DRACO_GEOMETRY,
           writePromise: () => writeFileForSlpk(slpkCompressedGeometryPath, compressedGeometry, '1.bin')
         });
       } else {
         const compressedGeometryPath = join(childPath, 'geometries/1/');
         await this.writeQueue.enqueue({
+          sourceId,
+          outputId: nodeId,
+          resourceType: ResourceType.DRACO_GEOMETRY,
           writePromise: () => writeFile(compressedGeometryPath, compressedGeometry, 'index.bin')
         });
       }
     }
   }
-  async _writeShared(sharedResources, childPath, slpkChildPath, nodePath) {
+  async _writeShared(sharedResources, childPath, slpkChildPath, nodePath, sourceId, nodeId) {
     if (!sharedResources) {
       return;
     }
     sharedResources.nodePath = nodePath;
     const sharedData = transform(sharedResources, sharedResourcesTemplate());
     const sharedDataStr = JSON.stringify(sharedData);
+    this.conversionDump.updateDoneStatus(sourceId, nodeId, ResourceType.SHARED, false);
     if (this.options.slpk) {
       const slpkSharedPath = join(childPath, 'shared');
       await this.writeQueue.enqueue({
         archiveKey: `${slpkChildPath}/shared/sharedResource.json.gz`,
+        sourceId,
+        outputId: nodeId,
+        resourceType: ResourceType.SHARED,
         writePromise: () => writeFileForSlpk(slpkSharedPath, sharedDataStr, 'sharedResource.json')
       });
     } else {
       const sharedPath = join(childPath, 'shared/');
       await this.writeQueue.enqueue({
+        sourceId,
+        outputId: nodeId,
+        resourceType: ResourceType.SHARED,
         writePromise: () => writeFile(sharedPath, sharedDataStr)
       });
     }
   }
-  async _writeTexture(texture, childPath, slpkChildPath) {
+  async _writeTexture(texture, childPath, slpkChildPath, sourceId, nodeId) {
     if (texture) {
       const format = this._getFormatByMimeType(texture === null || texture === void 0 ? void 0 : texture.mimeType);
       const formats = [];
@@ -632,7 +758,8 @@ export default class I3SConverter {
               name: '0',
               format
             });
-            await this.writeTextureFile(textureData, '0', format, childPath, slpkChildPath);
+            this.conversionDump.updateDoneStatus(sourceId, nodeId, `${ResourceType.TEXTURE}/${format}`, false);
+            await this.writeTextureFile(textureData, '0', format, childPath, slpkChildPath, sourceId, nodeId);
             if (this.generateTextures) {
               formats.push({
                 name: '1',
@@ -652,7 +779,8 @@ export default class I3SConverter {
                 _nodeWorkers: true,
                 useLocalLibraries: true
               });
-              await this.writeTextureFile(ktx2TextureData, '1', 'ktx2', childPath, slpkChildPath);
+              this.conversionDump.updateDoneStatus(sourceId, nodeId, `${ResourceType.TEXTURE}/ktx2`, false);
+              await this.writeTextureFile(ktx2TextureData, '1', 'ktx2', childPath, slpkChildPath, sourceId, nodeId);
             }
             break;
           }
@@ -662,14 +790,16 @@ export default class I3SConverter {
               name: '1',
               format
             });
-            await this.writeTextureFile(textureData, '1', format, childPath, slpkChildPath);
+            this.conversionDump.updateDoneStatus(sourceId, nodeId, `${ResourceType.TEXTURE}/${format}`, false);
+            await this.writeTextureFile(textureData, '1', format, childPath, slpkChildPath, sourceId, nodeId);
             if (this.generateTextures) {
               formats.push({
                 name: '0',
                 format: 'jpg'
               });
               const decodedFromKTX2TextureData = encode(texture.image.data[0], ImageWriter);
-              await this.writeTextureFile(decodedFromKTX2TextureData, '0', 'jpg', childPath, slpkChildPath);
+              this.conversionDump.updateDoneStatus(sourceId, nodeId, `${ResourceType.TEXTURE}/jpg`, false);
+              await this.writeTextureFile(decodedFromKTX2TextureData, '0', 'jpg', childPath, slpkChildPath, sourceId, nodeId);
             }
           }
       }
@@ -681,20 +811,29 @@ export default class I3SConverter {
           formats,
           atlas: true
         });
+        if (this.layers0.textureSetDefinitions) {
+          this.conversionDump.addTexturesDefinitions(this.layers0.textureSetDefinitions);
+        }
       }
     }
   }
-  async writeTextureFile(textureData, name, format, childPath, slpkChildPath) {
+  async writeTextureFile(textureData, name, format, childPath, slpkChildPath, sourceId, nodeId) {
     if (this.options.slpk) {
       const slpkTexturePath = join(childPath, 'textures');
       const compress = false;
       await this.writeQueue.enqueue({
         archiveKey: `${slpkChildPath}/textures/${name}.${format}`,
+        sourceId,
+        outputId: nodeId,
+        resourceType: `${ResourceType.TEXTURE}/${format}`,
         writePromise: () => writeFileForSlpk(slpkTexturePath, textureData, `${name}.${format}`, compress)
       });
     } else {
       const texturePath = join(childPath, `textures/${name}/`);
       await this.writeQueue.enqueue({
+        sourceId,
+        outputId: nodeId,
+        resourceType: `${ResourceType.TEXTURE}/${format}`,
         writePromise: () => writeFile(texturePath, textureData, `index.${format}`)
       });
     }
@@ -703,20 +842,29 @@ export default class I3SConverter {
     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;
+    let sourceId = arguments.length > 3 ? arguments[3] : undefined;
+    let nodeId = arguments.length > 4 ? arguments[4] : undefined;
     if (attributes !== null && attributes !== void 0 && attributes.length && this.attributeMetadataInfo.attributeStorageInfo.length) {
       const minimumLength = attributes.length < this.attributeMetadataInfo.attributeStorageInfo.length ? attributes.length : this.attributeMetadataInfo.attributeStorageInfo.length;
       for (let index = 0; index < minimumLength; index++) {
         const folderName = this.attributeMetadataInfo.attributeStorageInfo[index].key;
         const fileBuffer = new Uint8Array(attributes[index]);
+        this.conversionDump.updateDoneStatus(sourceId, nodeId, `${ResourceType.ATTRIBUTES}/${folderName}`, false);
         if (this.options.slpk) {
           const slpkAttributesPath = join(childPath, 'attributes', folderName);
           await this.writeQueue.enqueue({
             archiveKey: `${slpkChildPath}/attributes/${folderName}.bin.gz`,
+            sourceId,
+            outputId: nodeId,
+            resourceType: `${ResourceType.ATTRIBUTES}/${folderName}`,
             writePromise: () => writeFileForSlpk(slpkAttributesPath, fileBuffer, '0.bin')
           });
         } else {
           const attributesPath = join(childPath, `attributes/${folderName}/0`);
           await this.writeQueue.enqueue({
+            sourceId,
+            outputId: nodeId,
+            resourceType: `${ResourceType.ATTRIBUTES}/${folderName}`,
             writePromise: () => writeFile(attributesPath, fileBuffer, 'index.bin')
           });
         }