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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loaders.gl/tile-converter",
-  "version": "4.1.0-alpha.1",
+  "version": "4.1.0-alpha.10",
   "description": "Converter",
   "license": "MIT",
   "type": "module",
@@ -21,9 +21,9 @@
   "module": "dist/index.js",
   "exports": {
     ".": {
+      "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
-      "require": "./dist/index.cjs",
-      "types": "./dist/index.d.ts"
+      "require": "./dist/index.cjs"
     }
   },
   "sideEffects": false,
@@ -52,18 +52,18 @@
     "build-i3s-server-bundle": "esbuild src/i3s-server/bin/www.ts --outfile=dist/i3s-server/bin/i3s-server.min.cjs --platform=node --target=esnext,node14 --minify --bundle --define:__VERSION__=\\\"$npm_package_version\\\""
   },
   "dependencies": {
-    "@loaders.gl/3d-tiles": "4.1.0-alpha.1",
-    "@loaders.gl/crypto": "4.1.0-alpha.1",
-    "@loaders.gl/draco": "4.1.0-alpha.1",
-    "@loaders.gl/gltf": "4.1.0-alpha.1",
-    "@loaders.gl/i3s": "4.1.0-alpha.1",
-    "@loaders.gl/images": "4.1.0-alpha.1",
-    "@loaders.gl/loader-utils": "4.1.0-alpha.1",
-    "@loaders.gl/polyfills": "4.1.0-alpha.1",
-    "@loaders.gl/textures": "4.1.0-alpha.1",
-    "@loaders.gl/tiles": "4.1.0-alpha.1",
-    "@loaders.gl/worker-utils": "4.1.0-alpha.1",
-    "@loaders.gl/zip": "4.1.0-alpha.1",
+    "@loaders.gl/3d-tiles": "4.1.0-alpha.10",
+    "@loaders.gl/crypto": "4.1.0-alpha.10",
+    "@loaders.gl/draco": "4.1.0-alpha.10",
+    "@loaders.gl/gltf": "4.1.0-alpha.10",
+    "@loaders.gl/i3s": "4.1.0-alpha.10",
+    "@loaders.gl/images": "4.1.0-alpha.10",
+    "@loaders.gl/loader-utils": "4.1.0-alpha.10",
+    "@loaders.gl/polyfills": "4.1.0-alpha.10",
+    "@loaders.gl/textures": "4.1.0-alpha.10",
+    "@loaders.gl/tiles": "4.1.0-alpha.10",
+    "@loaders.gl/worker-utils": "4.1.0-alpha.10",
+    "@loaders.gl/zip": "4.1.0-alpha.10",
     "@math.gl/core": "^4.0.0",
     "@math.gl/culling": "^4.0.0",
     "@math.gl/geoid": "^4.0.0",
@@ -87,7 +87,7 @@
     "join-images": "^1.1.3",
     "sharp": "^0.31.3"
   },
-  "gitHead": "6a4d3da93d45115ad99861474a43c3f4a0b280a7",
+  "gitHead": "19f43c2d90d8b50860c3f8e487429779a386287d",
   "devDependencies": {
     "@types/express": "^4.17.17",
     "@types/node": "^20.4.2"

package/src/constants.ts

@@ -1,2 +1,3 @@
 export const BROWSER_ERROR_MESSAGE =
   'Tile converter does not work in browser, only in node js environment';
+export const DUMP_FILE_SUFFIX = '.dump.json';

package/src/converter-cli.ts

@@ -11,6 +11,9 @@ import {
   getURLValue,
   validateOptionsWithEqual
 } from './lib/utils/cli-utils';
+import {addOneFile, composeHashFile} from '@loaders.gl/zip';
+import {FileHandleFile} from '@loaders.gl/loader-utils';
+import {copyFile} from 'node:fs/promises';
 
 type TileConversionOptions = {
   /** "I3S" - for I3S to 3DTiles conversion, "3DTILES" for 3DTiles to I3S conversion */
@@ -50,6 +53,8 @@ type TileConversionOptions = {
   maxDepth?: number;
   /** 3DTiles->I3S only. Whether the converter generates *.slpk (Scene Layer Package) I3S output file */
   slpk: boolean;
+  /** adds hash file to the slpk if there's no one */
+  addHash: boolean;
   /** Feature metadata class from EXT_FEATURE_METADATA or EXT_STRUCTURAL_METADATA extensions  */
   metadataClass?: string;
   /** With this options the tileset content will be analyzed without conversion */
@@ -92,6 +97,48 @@ async function main() {
     return;
   }
 
+  if (options.addHash) {
+    const validatedOptions = validateOptions(options, true);
+    let finalPath = validatedOptions.tileset;
+    if (validatedOptions.output === 'data') {
+      const nameWithoutExt = validatedOptions.tileset.substring(
+        0,
+        validatedOptions.tileset.length - 5
+      );
+
+      const result = await inquirer.prompt<{isNewFileRequired: boolean}>([
+        {
+          name: 'isNewFileRequired',
+          type: 'list',
+          message: 'What would you like to do?',
+          choices: [
+            {
+              name: 'Add hash file to the current SLPK file',
+              value: false
+            },
+            {
+              name: `Create a new file ${nameWithoutExt}-hash.slpk with hash file inside`,
+              value: true
+            }
+          ]
+        }
+      ]);
+
+      if (result.isNewFileRequired) {
+        finalPath = `${nameWithoutExt}-hash.slpk`;
+      }
+    } else {
+      finalPath = validatedOptions.output;
+    }
+    if (finalPath !== validatedOptions.tileset) {
+      await copyFile(validatedOptions.tileset, finalPath);
+    }
+    const hashTable = await composeHashFile(new FileHandleFile(finalPath));
+    await addOneFile(finalPath, hashTable, '@specialIndexFileHASH128@');
+
+    return;
+  }
+
   const validatedOptions: ValidatedTileConversionOptions = validateOptions(options);
 
   await convert(validatedOptions);
@@ -199,7 +246,10 @@ async function convert(options: ValidatedTileConversionOptions) {
  * @param options - input options of the CLI command
  * @returns validated options
  */
-function validateOptions(options: TileConversionOptions): ValidatedTileConversionOptions {
+function validateOptions(
+  options: TileConversionOptions,
+  addHash?: boolean
+): ValidatedTileConversionOptions {
   const mandatoryOptionsWithExceptions: {
     [key: string]: {
       getMessage: () => void;
@@ -208,7 +258,7 @@ function validateOptions(options: TileConversionOptions): ValidatedTileConversio
   } = {
     name: {
       getMessage: () => console.log('Missed: --name [Tileset name]'),
-      condition: (value: any) => Boolean(value) || Boolean(options.analyze)
+      condition: (value: any) => addHash || Boolean(value) || Boolean(options.analyze)
     },
     output: {getMessage: () => console.log('Missed: --output [Output path name]')},
     sevenZipExe: {getMessage: () => console.log('Missed: --7zExe [7z archiver executable path]')},
@@ -218,7 +268,7 @@ function validateOptions(options: TileConversionOptions): ValidatedTileConversio
       getMessage: () =>
         console.log('Missed/Incorrect: --input-type [tileset input type: I3S or 3DTILES]'),
       condition: (value) =>
-        Boolean(value) && Object.values(TILESET_TYPE).includes(value.toUpperCase())
+        addHash || (Boolean(value) && Object.values(TILESET_TYPE).includes(value.toUpperCase()))
     }
   };
   const exceptions: (() => void)[] = [];
@@ -256,7 +306,8 @@ function parseOptions(args: string[]): TileConversionOptions {
     generateTextures: false,
     generateBoundingVolumes: false,
     validate: false,
-    slpk: false
+    slpk: false,
+    addHash: false
   };
 
   // eslint-disable-next-line complexity
@@ -287,6 +338,9 @@ function parseOptions(args: string[]): TileConversionOptions {
         case '--slpk':
           opts.slpk = getBooleanValue(index, args);
           break;
+        case '--add-hash':
+          opts.addHash = getBooleanValue(index, args);
+          break;
         case '--7zExe':
           opts.sevenZipExe = getStringValue(index, args);
           break;

package/src/deps-installer/deps-installer.ts

@@ -1,7 +1,7 @@
 import {load, fetchFile} from '@loaders.gl/core';
 import {ZipLoader} from '@loaders.gl/zip';
 import {writeFile} from '../lib/utils/file-utils';
-import {join} from 'path';
+import {join, dirname} from 'path';
 import {ChildProcessProxy} from '@loaders.gl/worker-utils';
 import {DRACO_EXTERNAL_LIBRARIES, DRACO_EXTERNAL_LIBRARY_URLS} from '@loaders.gl/draco';
 import {BASIS_EXTERNAL_LIBRARIES} from '@loaders.gl/textures';
@@ -80,8 +80,9 @@ export class DepsInstaller {
 
     console.log('Installing "join-images" npm package');
     const childProcess = new ChildProcessProxy();
+    const nodeDir = dirname(process.execPath);
     await childProcess.start({
-      command: process.platform === 'win32' ? 'npm.cmd' : 'npm',
+      command: `${nodeDir}/${process.platform === 'win32' ? 'npm.cmd' : 'npm'}`,
       // `npm install sharp join-images` works unstable. It fails because installed `sharp` version
       // may be different from the version required by `join-images`. Pointing to specific versions
       // resolve this issue

package/src/i3s-converter/i3s-converter.ts

@@ -1,4 +1,5 @@
-// loaders.gl, MIT license
+// loaders.gl
+// SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
 import {AttributeMetadataInfo} from './helpers/attribute-metadata-info';
@@ -50,7 +51,7 @@ import {GEOMETRY_DEFINITION as geometryDefinitionTemlate} from './json-templates
 import {SHARED_RESOURCES as sharedResourcesTemplate} from './json-templates/shared-resources';
 import {validateNodeBoundingVolumes} from './helpers/node-debug';
 import {KTX2BasisWriterWorker} from '@loaders.gl/textures';
-import {LoaderWithParser} from '@loaders.gl/loader-utils';
+import {FileHandleFile, LoaderWithParser} from '@loaders.gl/loader-utils';
 import {I3SMaterialDefinition, TextureSetDefinitionFormats} from '@loaders.gl/i3s';
 import {ImageWriter} from '@loaders.gl/images';
 import {GLTFImagePostprocessed} from '@loaders.gl/gltf';
@@ -58,6 +59,7 @@ import {
   GLTFPrimitiveModeString,
   I3SConvertedResources,
   PreprocessData,
+  ResourceType,
   SharedResourcesArrays
 } from './types';
 import {WorkerFarm} from '@loaders.gl/worker-utils';
@@ -80,6 +82,8 @@ import {createBoundingVolume} from '@loaders.gl/tiles';
 import {TraversalConversionProps, traverseDatasetWith} from './helpers/tileset-traversal';
 import {analyzeTileContent, mergePreprocessData} from './helpers/preprocess-3d-tiles';
 import {Progress} from './helpers/progress';
+import {addOneFile, composeHashFile} from '@loaders.gl/zip';
+import {ConversionDump, ConversionDumpOptions} from '../lib/utils/conversion-dump';
 
 const ION_DEFAULT_TOKEN = process.env?.IonToken;
 const HARDCODED_NODES_PER_PAGE = 64;
@@ -134,13 +138,14 @@ export default class I3SConverter {
   generateBoundingVolumes: boolean;
   layersHasTexture: boolean;
   workerSource: {[key: string]: string} = {};
-  writeQueue: WriteQueue<WriteQueueItem> = new WriteQueue();
+  writeQueue: WriteQueue<WriteQueueItem> = new WriteQueue(new ConversionDump());
   compressList: string[] | null = null;
   preprocessData: PreprocessData = {
     meshTopologyTypes: new Set(),
     metadataClasses: new Set()
   };
   progresses: Record<string, Progress> = {};
+  conversionDump: ConversionDump;
 
   constructor() {
     this.attributeMetadataInfo = new AttributeMetadataInfo();
@@ -163,6 +168,7 @@ export default class I3SConverter {
     this.generateBoundingVolumes = false;
     this.layersHasTexture = false;
     this.compressList = null;
+    this.conversionDump = new ConversionDump();
   }
 
   /**
@@ -226,6 +232,8 @@ export default class I3SConverter {
       analyze = false
     } = options;
     this.options = {
+      outputPath,
+      tilesetName,
       maxDepth,
       slpk,
       sevenZipExe,
@@ -245,7 +253,7 @@ export default class I3SConverter {
     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...'); // eslint-disable-line
@@ -256,6 +264,9 @@ export default class I3SConverter {
       this.nodePages.useWriteFunction(writeFileForSlpk);
     }
 
+    //create a dump file with convertion options
+    await this.conversionDump.createDumpFile(options as ConversionDumpOptions);
+
     try {
       const preloadOptions = await this._fetchPreloadOptions();
       let tilesetUrl = inputUrl;
@@ -552,6 +563,7 @@ export default class I3SConverter {
    * @param tilesetPath - Path to save file
    */
   private async _createSlpk(tilesetPath: string): Promise<void> {
+    await this.conversionDump.deleteDumpFile();
     if (this.options.slpk) {
       const slpkTilesetPath = join(tilesetPath, 'SceneServer', 'layers', '0');
       const slpkFileName = `${tilesetPath}.slpk`;
@@ -563,6 +575,9 @@ export default class I3SConverter {
         this.options.sevenZipExe
       );
 
+      const hashTable = await composeHashFile(new FileHandleFile(slpkFileName));
+      await addOneFile(slpkFileName, hashTable, '@specialIndexFileHASH128@');
+
       // TODO: `addFileToZip` corrupts archive so it can't be validated with windows i3s_converter.exe
       // const fileHash128Path = `${tilesetPath}/@specialIndexFileHASH128@`;
       // try {
@@ -613,6 +628,7 @@ export default class I3SConverter {
     if (sourceTile.id) {
       console.log(`[convert]: ${sourceTile.id}`); // eslint-disable-line
     }
+
     const {parentNodes, transform} = traversalProps;
     let transformationMatrix: Matrix4 = transform.clone();
     if (sourceTile.transform) {
@@ -751,7 +767,13 @@ export default class I3SConverter {
       nodes.push(node);
 
       if (nodeInPage.mesh) {
-        await this._writeResources(resources, node.id);
+        //update a record in a dump file
+        if (sourceTile.id) {
+          await this.conversionDump.addNode(sourceTile.id, nodeInPage.index);
+        }
+
+        //write resources
+        await this._writeResources(resources, node.id, sourceTile);
       }
 
       if (this.validate) {
@@ -900,9 +922,15 @@ export default class I3SConverter {
    * @param resources.texture - texture image
    * @param resources.sharedResources - shared resource data object
    * @param resources.attributes - feature attributes
+   * @param nodePath - node path
+   * @param sourceTile - source tile (3DTile)
    * @return {Promise<void>}
    */
-  private async _writeResources(resources: I3SConvertedResources, nodePath: string): Promise<void> {
+  private async _writeResources(
+    resources: I3SConvertedResources,
+    nodePath: string,
+    sourceTile: Tiles3DTileJSONPostprocessed
+  ): Promise<void> {
     const {
       geometry: geometryBuffer,
       compressedGeometry,
@@ -913,10 +941,36 @@ export default class I3SConverter {
     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)
+    );
   }
 
   /**
@@ -925,37 +979,57 @@ export default class I3SConverter {
    * @param compressedGeometry - Uint8Array with compressed (draco) geometry
    * @param childPath - a child path to write resources
    * @param slpkChildPath - resource path inside *slpk file
+   * @param sourceId - source filename
+   * @param nodeId - nodeId of a converted node for the writing
    */
   private async _writeGeometries(
     geometryBuffer: ArrayBuffer,
     compressedGeometry: Promise<ArrayBuffer>,
     childPath: string,
-    slpkChildPath: string
+    slpkChildPath: string,
+    sourceId: string,
+    nodeId: number
   ): Promise<void> {
+    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')
         });
       }
@@ -968,12 +1042,16 @@ export default class I3SConverter {
    * @param childPath - a child path to write resources
    * @param slpkChildPath - resource path inside *slpk file
    * @param nodePath - a node path
+   * @param sourceId - source filename
+   * @param nodeId - nodeId of a converted node for the writing
    */
   private async _writeShared(
     sharedResources: SharedResourcesArrays | null,
     childPath: string,
     slpkChildPath: string,
-    nodePath: string
+    nodePath: string,
+    sourceId: string,
+    nodeId: number
   ): Promise<void> {
     if (!sharedResources) {
       return;
@@ -981,15 +1059,24 @@ export default class I3SConverter {
     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({writePromise: () => writeFile(sharedPath, sharedDataStr)});
+      await this.writeQueue.enqueue({
+        sourceId,
+        outputId: nodeId,
+        resourceType: ResourceType.SHARED,
+        writePromise: () => writeFile(sharedPath, sharedDataStr)
+      });
     }
   }
 
@@ -998,11 +1085,15 @@ export default class I3SConverter {
    * @param texture - the texture image
    * @param childPath - a child path to write resources
    * @param slpkChildPath - the resource path inside *slpk file
+   * @param sourceId - source filename
+   * @param nodeId - nodeId of a converted node for the writing
    */
   private async _writeTexture(
     texture: GLTFImagePostprocessed,
     childPath: string,
-    slpkChildPath: string
+    slpkChildPath: string,
+    sourceId: string,
+    nodeId: number
   ): Promise<void> {
     if (texture) {
       const format = this._getFormatByMimeType(texture?.mimeType);
@@ -1013,7 +1104,21 @@ export default class I3SConverter {
         case 'jpg':
         case 'png': {
           formats.push({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', format: 'ktx2'});
@@ -1022,6 +1127,7 @@ export default class I3SConverter {
             const arrayToEncode = new Uint8Array(copyArrayBuffer);
             const ktx2TextureData = encode(
               {...texture.image, data: arrayToEncode},
+              // @ts-expect-error - Worker encoder typing is still WIP
               KTX2BasisWriterWorker,
               {
                 ...KTX2BasisWriterWorker.options,
@@ -1035,7 +1141,22 @@ export default class I3SConverter {
               }
             );
 
-            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;
@@ -1043,17 +1164,39 @@ export default class I3SConverter {
 
         case 'ktx2': {
           formats.push({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);
+            this.conversionDump.updateDoneStatus(
+              sourceId,
+              nodeId,
+              `${ResourceType.TEXTURE}/jpg`,
+              false
+            );
             await this.writeTextureFile(
               decodedFromKTX2TextureData,
               '0',
               'jpg',
               childPath,
-              slpkChildPath
+              slpkChildPath,
+              sourceId,
+              nodeId
             );
           }
         }
@@ -1073,13 +1216,17 @@ export default class I3SConverter {
    * @param format
    * @param childPath
    * @param slpkChildPath
+   * @param sourceId
+   * @param nodeId
    */
   private async writeTextureFile(
     textureData: Uint8Array | Promise<ArrayBuffer>,
     name: string,
     format: 'jpg' | 'png' | 'ktx2',
     childPath: string,
-    slpkChildPath: string
+    slpkChildPath: string,
+    sourceId: string,
+    nodeId: number
   ): Promise<void> {
     if (this.options.slpk) {
       const slpkTexturePath = join(childPath, 'textures');
@@ -1087,12 +1234,18 @@ export default class I3SConverter {
 
       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}`)
       });
     }
@@ -1103,11 +1256,15 @@ export default class I3SConverter {
    * @param attributes - feature attributes
    * @param childPath - a child path to write resources
    * @param slpkChildPath - the resource path inside *slpk file
+   * @param sourceId - source filename
+   * @param nodeId - nodeId of a converted node for the writing
    */
   private async _writeAttributes(
     attributes: ArrayBuffer[] | null = [],
     childPath: string,
-    slpkChildPath: string
+    slpkChildPath: string,
+    sourceId: string,
+    nodeId: number
   ): Promise<void> {
     if (attributes?.length && this.attributeMetadataInfo.attributeStorageInfo.length) {
       const minimumLength =
@@ -1118,16 +1275,27 @@ export default class I3SConverter {
       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')
           });
         }

package/src/i3s-converter/types.ts

@@ -241,3 +241,11 @@ export const AttributeType = {
   /** Integer data type name for feature attributes */
   SHORT_INT_TYPE: 'Int32'
 } as const;
+
+export enum ResourceType {
+  ATTRIBUTES = 'ATTRIBUTES',
+  DRACO_GEOMETRY = 'DRACO_GEOMETRY',
+  GEOMETRY = 'GEOMETRY',
+  SHARED = 'SHARED',
+  TEXTURE = 'TEXTURE'
+}