@loaders.gl/tile-converter 3.1.8 → 3.2.0-alpha.3

package/src/i3s-converter/helpers/gltf-attributes.ts

@@ -0,0 +1,68 @@
+import type {B3DMContent} from '@loaders.gl/3d-tiles';
+import type {Accessor} from 'modules/gltf/src/lib/types/gltf-postprocessed-schema';
+import type {B3DMAttributesData} from '../../i3s-attributes-worker';
+
+type AttributesObject = {
+  [k: string]: Accessor;
+};
+
+/**
+ * Keep only values for B3DM attributes to pass data to worker thread.
+ * @param attributes
+ */
+function getB3DMAttributesWithoutBufferView(attributes: AttributesObject): AttributesObject {
+  const attributesWithoutBufferView = {};
+
+  for (const attributeName in attributes) {
+    attributesWithoutBufferView[attributeName] = {
+      value: attributes[attributeName].value
+    };
+  }
+
+  return attributesWithoutBufferView;
+}
+
+/**
+ * Prepare attributes for conversion to avoid binary data breaking in worker thread.
+ * @param tileContent
+ * @returns
+ */
+export function prepareDataForAttributesConversion(tileContent: B3DMContent): B3DMAttributesData {
+  const gltfMaterials = tileContent.gltf?.materials?.map((material) => ({id: material.id}));
+  let nodes =
+    tileContent.gltf?.scene?.nodes ||
+    tileContent.gltf?.scenes?.[0]?.nodes ||
+    tileContent.gltf?.nodes ||
+    [];
+
+  const prepearedNodes = nodes.map((node) => {
+    if (!node.mesh) {
+      return node;
+    }
+
+    return {
+      ...node,
+      mesh: {
+        ...node.mesh,
+        primitives: node.mesh?.primitives.map((primitive) => ({
+          ...primitive,
+          indices: {value: primitive?.indices?.value},
+          attributes: getB3DMAttributesWithoutBufferView(primitive.attributes),
+          material: {
+            id: primitive?.material?.id
+          }
+        }))
+      }
+    };
+  });
+
+  const cartographicOrigin = tileContent.cartographicOrigin;
+  const cartesianModelMatrix = tileContent.cartesianModelMatrix;
+
+  return {
+    gltfMaterials,
+    nodes: prepearedNodes,
+    cartographicOrigin,
+    cartesianModelMatrix
+  };
+}

package/src/i3s-converter/helpers/node-pages.ts

@@ -1,7 +1,10 @@
+import type {WriteQueueItem} from '../../lib/utils/write-queue';
+
 import {join} from 'path';
 import transform from 'json-map-transform';
 import {METADATA as metadataTemplate} from '../json-templates/metadata';
 import {NodeInPage} from '@loaders.gl/i3s';
+import WriteQueue from '../../lib/utils/write-queue';
 
 // @ts-nocheck
 /**
@@ -188,35 +191,40 @@ export default class NodePages {
   /**
    * Save all the node pages
    * Run this method when all nodes is pushed in nodePages
-   * @param {string} layers0Path - path of layer
-   * @param {Object} fileMap - fileMap which keep info for slpk archive
-   * @param {boolean} slpk
-   * @return {promise}
+   * @param layers0Path - path of layer
+   * @param writeQueue - write queue that controlls files write concurrency
+   * @param slpk
    */
-  async save(layers0Path: string, fileMap: Object, slpk: boolean = false): Promise<void> {
+  async save(
+    layers0Path: string,
+    writeQueue: WriteQueue<WriteQueueItem>,
+    slpk: boolean = false
+  ): Promise<void> {
     if (slpk) {
       for (const [index, nodePage] of this.nodePages.entries()) {
         const nodePageStr = JSON.stringify(nodePage);
         const slpkPath = join(layers0Path, 'nodepages');
-        fileMap[`nodePages/${index.toString()}.json.gz`] = await this.writeFile(
-          slpkPath,
-          nodePageStr,
-          `${index.toString()}.json`
-        );
+        writeQueue.enqueue({
+          archiveKey: `nodePages/${index.toString()}.json.gz`,
+          writePromise: this.writeFile(slpkPath, nodePageStr, `${index.toString()}.json`)
+        });
       }
       const metadata = transform({nodeCount: this.nodesCounter}, metadataTemplate());
       const compress = false;
-      fileMap['metadata.json'] = await this.writeFile(
-        layers0Path,
-        JSON.stringify(metadata),
-        'metadata.json',
-        compress
-      );
+      writeQueue.enqueue({
+        archiveKey: 'metadata.json',
+        writePromise: this.writeFile(
+          layers0Path,
+          JSON.stringify(metadata),
+          'metadata.json',
+          compress
+        )
+      });
     } else {
       for (const [index, nodePage] of this.nodePages.entries()) {
         const nodePageStr = JSON.stringify(nodePage);
         const nodePagePath = join(layers0Path, 'nodepages', index.toString());
-        await this.writeFile(nodePagePath, nodePageStr);
+        writeQueue.enqueue({writePromise: this.writeFile(nodePagePath, nodePageStr)});
       }
     }
   }

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

@@ -1,6 +1,6 @@
 import type {Tile3D, Tileset3DProps} from '@loaders.gl/tiles';
 import type {BatchTableJson, B3DMContent} from '@loaders.gl/3d-tiles';
-
+import type {WriteQueueItem} from '../lib/utils/write-queue';
 import type {
   AttributeStorageInfo,
   SceneLayer3D,
@@ -10,14 +10,13 @@ import type {
   MaxScreenThresholdSQ,
   NodeInPage,
   LodSelection,
-  SharedResources,
   Attribute,
   ESRIField,
   Field,
   PopupInfo,
   FieldInfo
 } from '@loaders.gl/i3s';
-import {load, encode} from '@loaders.gl/core';
+import {load, encode, fetchFile, getLoaderOptions} from '@loaders.gl/core';
 import {Tileset3D} from '@loaders.gl/tiles';
 import {CesiumIonLoader, Tiles3DLoader} from '@loaders.gl/3d-tiles';
 import {Geoid} from '@math.gl/geoid';
@@ -38,7 +37,7 @@ import {calculateFilesSize, timeConverter} from '../lib/utils/statistic-utills';
 import convertB3dmToI3sGeometry from './helpers/geometry-converter';
 import {
   createBoundingVolumes,
-  convertCommonToI3SExtentCoordinate
+  convertBoundingVolumeToI3SFullExtent
 } from './helpers/coordinate-converter';
 import {createSceneServerPath} from './helpers/create-scene-server-path';
 import {convertGeometricErrorToScreenThreshold} from '../lib/utils/lod-conversion-utils';
@@ -49,12 +48,16 @@ import {NODE as nodeTemplate} from './json-templates/node';
 import {SHARED_RESOURCES as sharedResourcesTemplate} from './json-templates/shared-resources';
 import {validateNodeBoundingVolumes} from './helpers/node-debug';
 import TileHeader from '@loaders.gl/tiles/src/tileset/tile-3d';
-import {KTX2BasisUniversalTextureWriter} from '@loaders.gl/textures';
+import {KTX2BasisWriterWorker} from '@loaders.gl/textures';
 import {LoaderWithParser} from '@loaders.gl/loader-utils';
 import {I3SMaterialDefinition, TextureSetDefinitionFormats} from '@loaders.gl/i3s/src/types';
 import {ImageWriter} from '@loaders.gl/images';
 import {GLTFImagePostprocessed} from '@loaders.gl/gltf';
-import {I3SConvertedResources} from './types';
+import {I3SConvertedResources, SharedResourcesArrays} from './types';
+import {getWorkerURL, WorkerFarm} from '@loaders.gl/worker-utils';
+import {DracoWriterWorker} from '@loaders.gl/draco';
+import WriteQueue from '../lib/utils/write-queue';
+import {I3SAttributesWorker} from '../i3s-attributes-worker';
 
 const ION_DEFAULT_TOKEN =
   process.env.IonToken || // eslint-disable-line
@@ -75,7 +78,6 @@ const CESIUM_DATASET_PREFIX = 'https://';
  */
 export default class I3SConverter {
   nodePages: NodePages;
-  fileMap: {[key: string]: string};
   options: any;
   layers0Path: string;
   materialMap: Map<any, any>;
@@ -96,10 +98,12 @@ export default class I3SConverter {
   Loader: LoaderWithParser = Tiles3DLoader;
   generateTextures: boolean;
   generateBoundingVolumes: boolean;
+  layersHasTexture: boolean;
+  workerSource: {[key: string]: string} = {};
+  writeQueue: WriteQueue<WriteQueueItem> = new WriteQueue();
 
   constructor() {
     this.nodePages = new NodePages(writeFile, HARDCODED_NODES_PER_PAGE);
-    this.fileMap = {};
     this.options = {};
     this.layers0Path = '';
     this.materialMap = new Map();
@@ -114,6 +118,7 @@ export default class I3SConverter {
     this.validate = false;
     this.generateTextures = false;
     this.generateBoundingVolumes = false;
+    this.layersHasTexture = false;
   }
 
   /**
@@ -143,8 +148,6 @@ export default class I3SConverter {
     validate?: boolean;
     generateTextures?: boolean;
     generateBoundingVolumes?: boolean;
-    /** @deprecated */
-    inputType?: string;
   }): Promise<any> {
     this.conversionStartTime = process.hrtime();
     const {
@@ -167,6 +170,9 @@ export default class I3SConverter {
     this.generateTextures = Boolean(generateTextures);
     this.generateBoundingVolumes = Boolean(generateBoundingVolumes);
 
+    this.writeQueue = new WriteQueue();
+    this.writeQueue.startListening();
+
     console.log('Loading egm file...'); // eslint-disable-line
     this.geoidHeightModel = await load(egmFilePath, PGMLoader);
     console.log('Loading egm file completed!'); // eslint-disable-line
@@ -175,19 +181,29 @@ export default class I3SConverter {
       this.nodePages.useWriteFunction(writeFileForSlpk);
     }
 
-    const preloadOptions = await this._fetchPreloadOptions();
-    const tilesetOptions: Tileset3DProps = {loadOptions: {basis: {format: 'rgba32'}}};
-    if (preloadOptions.headers) {
-      tilesetOptions.loadOptions!.fetch = {headers: preloadOptions.headers};
+    await this.loadWorkers();
+
+    try {
+      const preloadOptions = await this._fetchPreloadOptions();
+      const tilesetOptions: Tileset3DProps = {loadOptions: {basis: {format: 'rgba32'}}};
+      if (preloadOptions.headers) {
+        tilesetOptions.loadOptions!.fetch = {headers: preloadOptions.headers};
+      }
+      Object.assign(tilesetOptions, preloadOptions);
+      const sourceTilesetJson = await load(inputUrl, this.Loader, tilesetOptions.loadOptions);
+      // console.log(tilesetJson); // eslint-disable-line
+      this.sourceTileset = new Tileset3D(sourceTilesetJson, tilesetOptions);
+
+      await this._createAndSaveTileset(outputPath, tilesetName);
+      await this._finishConversion({slpk: Boolean(slpk), outputPath, tilesetName});
+      return sourceTilesetJson;
+    } catch (error) {
+      throw error;
+    } finally {
+      // Clean up worker pools
+      const workerFarm = WorkerFarm.getWorkerFarm({});
+      workerFarm.destroy();
     }
-    Object.assign(tilesetOptions, preloadOptions);
-    const sourceTilesetJson = await load(inputUrl, this.Loader, tilesetOptions.loadOptions);
-    // console.log(tilesetJson); // eslint-disable-line
-    this.sourceTileset = new Tileset3D(sourceTilesetJson, tilesetOptions);
-
-    await this._createAndSaveTileset(outputPath, tilesetName);
-    await this._finishConversion({slpk: Boolean(slpk), outputPath, tilesetName});
-    return sourceTilesetJson;
   }
 
   /**
@@ -226,10 +242,19 @@ export default class I3SConverter {
     await this._convertNodesTree(root0, sourceRootTile, parentId, boundingVolumes);
 
     this.layers0!.materialDefinitions = this.materialDefinitions;
+
+    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.fileMap, isCreateSlpk);
+    await this.nodePages.save(this.layers0Path, this.writeQueue, isCreateSlpk);
+    await this.writeQueue.finalize();
     await this._createSlpk(tilesetPath);
   }
 
@@ -238,7 +263,10 @@ export default class I3SConverter {
    * @param  tilesetName - Name of layer
    */
   private _formLayers0(tilesetName: string): void {
-    const extent = convertCommonToI3SExtentCoordinate(this.sourceTileset);
+    const fullExtent = convertBoundingVolumeToI3SFullExtent(
+      this.sourceTileset?.boundingVolume || this.sourceTileset?.root?.boundingVolume
+    );
+    const extent = [fullExtent.xmin, fullExtent.ymin, fullExtent.xmax, fullExtent.ymax];
     const layers0data = {
       version: `{${uuidv4().toUpperCase()}}`,
       id: 0,
@@ -308,13 +336,16 @@ export default class I3SConverter {
       const childPath = join(this.layers0Path, 'nodes', child.path!);
 
       if (this.options.slpk) {
-        this.fileMap['nodes/1/3dNodeIndexDocument.json.gz'] = await writeFileForSlpk(
-          childPath,
-          JSON.stringify(child),
-          '3dNodeIndexDocument.json'
-        );
+        this.writeQueue.enqueue({
+          archiveKey: 'nodes/1/3dNodeIndexDocument.json.gz',
+          writePromise: writeFileForSlpk(
+            childPath,
+            JSON.stringify(child),
+            '3dNodeIndexDocument.json'
+          )
+        });
       } else {
-        await writeFile(childPath, JSON.stringify(child));
+        this.writeQueue.enqueue({writePromise: writeFile(childPath, JSON.stringify(child))});
       }
     } else {
       await this._addChildrenWithNeighborsAndWriteFile({
@@ -332,13 +363,18 @@ export default class I3SConverter {
    */
   private async _writeLayers0(): Promise<void> {
     if (this.options.slpk) {
-      this.fileMap['3dSceneLayer.json.gz'] = await writeFileForSlpk(
-        this.layers0Path,
-        JSON.stringify(this.layers0),
-        '3dSceneLayer.json'
-      );
+      this.writeQueue.enqueue({
+        archiveKey: '3dSceneLayer.json.gz',
+        writePromise: writeFileForSlpk(
+          this.layers0Path,
+          JSON.stringify(this.layers0),
+          '3dSceneLayer.json'
+        )
+      });
     } else {
-      await writeFile(this.layers0Path, JSON.stringify(this.layers0));
+      this.writeQueue.enqueue({
+        writePromise: writeFile(this.layers0Path, JSON.stringify(this.layers0))
+      });
     }
   }
 
@@ -351,13 +387,12 @@ export default class I3SConverter {
     rootPath: string
   ): Promise<void> {
     if (this.options.slpk) {
-      this.fileMap[`nodes/${nodePath}/3dNodeIndexDocument.json.gz`] = await writeFileForSlpk(
-        rootPath,
-        JSON.stringify(root0),
-        '3dNodeIndexDocument.json'
-      );
+      this.writeQueue.enqueue({
+        archiveKey: `nodes/${nodePath}/3dNodeIndexDocument.json.gz`,
+        writePromise: writeFileForSlpk(rootPath, JSON.stringify(root0), '3dNodeIndexDocument.json')
+      });
     } else {
-      await writeFile(rootPath, JSON.stringify(root0));
+      this.writeQueue.enqueue({writePromise: writeFile(rootPath, JSON.stringify(root0))});
     }
   }
 
@@ -374,7 +409,6 @@ export default class I3SConverter {
         slpkFileName,
         0,
         '.',
-        // @ts-expect-error
         this.options.sevenZipExe
       );
 
@@ -556,6 +590,8 @@ export default class I3SConverter {
     };
 
     for (const resources of resourcesData || [emptyResources]) {
+      this.layersHasTexture = this.layersHasTexture || Boolean(resources.texture);
+
       if (this.generateBoundingVolumes && resources.boundingVolumes) {
         boundingVolumes = resources.boundingVolumes;
       }
@@ -644,7 +680,8 @@ export default class I3SConverter {
       this.layers0?.attributeStorageInfo,
       this.options.draco,
       this.generateBoundingVolumes,
-      this.geoidHeightModel!
+      this.geoidHeightModel!,
+      this.workerSource
     );
     return resourcesData;
   }
@@ -794,7 +831,7 @@ export default class I3SConverter {
     const slpkChildPath = join('nodes', nodePath);
 
     await this._writeGeometries(geometryBuffer!, compressedGeometry!, childPath, slpkChildPath);
-    await this._writeShared(sharedResources!, childPath, slpkChildPath, nodePath);
+    await this._writeShared(sharedResources, childPath, slpkChildPath, nodePath);
     await this._writeTexture(texture, childPath, slpkChildPath);
     await this._writeAttributes(attributes, childPath, slpkChildPath);
   }
@@ -808,33 +845,35 @@ export default class I3SConverter {
    */
   private async _writeGeometries(
     geometryBuffer: ArrayBuffer,
-    compressedGeometry: ArrayBuffer,
+    compressedGeometry: Promise<ArrayBuffer>,
     childPath: string,
     slpkChildPath: string
   ): Promise<void> {
     if (this.options.slpk) {
       const slpkGeometryPath = join(childPath, 'geometries');
-      this.fileMap[`${slpkChildPath}/geometries/0.bin.gz`] = await writeFileForSlpk(
-        slpkGeometryPath,
-        geometryBuffer,
-        '0.bin'
-      );
+      this.writeQueue.enqueue({
+        archiveKey: `${slpkChildPath}/geometries/0.bin.gz`,
+        writePromise: writeFileForSlpk(slpkGeometryPath, geometryBuffer, '0.bin')
+      });
     } else {
       const geometryPath = join(childPath, 'geometries/0/');
-      await writeFile(geometryPath, geometryBuffer, 'index.bin');
+      this.writeQueue.enqueue({
+        writePromise: writeFile(geometryPath, geometryBuffer, 'index.bin')
+      });
     }
 
     if (this.options.draco) {
       if (this.options.slpk) {
         const slpkCompressedGeometryPath = join(childPath, 'geometries');
-        this.fileMap[`${slpkChildPath}/geometries/1.bin.gz`] = await writeFileForSlpk(
-          slpkCompressedGeometryPath,
-          compressedGeometry,
-          '1.bin'
-        );
+        this.writeQueue.enqueue({
+          archiveKey: `${slpkChildPath}/geometries/1.bin.gz`,
+          writePromise: writeFileForSlpk(slpkCompressedGeometryPath, compressedGeometry, '1.bin')
+        });
       } else {
         const compressedGeometryPath = join(childPath, 'geometries/1/');
-        await writeFile(compressedGeometryPath, compressedGeometry, 'index.bin');
+        this.writeQueue.enqueue({
+          writePromise: writeFile(compressedGeometryPath, compressedGeometry, 'index.bin')
+        });
       }
     }
   }
@@ -847,24 +886,26 @@ export default class I3SConverter {
    * @param nodePath - a node path
    */
   private async _writeShared(
-    sharedResources: SharedResources,
+    sharedResources: SharedResourcesArrays | null,
     childPath: string,
     slpkChildPath: string,
     nodePath: string
   ): Promise<void> {
+    if (!sharedResources) {
+      return;
+    }
     sharedResources.nodePath = nodePath;
     const sharedData = transform(sharedResources, sharedResourcesTemplate());
     const sharedDataStr = JSON.stringify(sharedData);
     if (this.options.slpk) {
       const slpkSharedPath = join(childPath, 'shared');
-      this.fileMap[`${slpkChildPath}/shared/sharedResource.json.gz`] = await writeFileForSlpk(
-        slpkSharedPath,
-        sharedDataStr,
-        'sharedResource.json'
-      );
+      this.writeQueue.enqueue({
+        archiveKey: `${slpkChildPath}/shared/sharedResource.json.gz`,
+        writePromise: writeFileForSlpk(slpkSharedPath, sharedDataStr, 'sharedResource.json')
+      });
     } else {
       const sharedPath = join(childPath, 'shared/');
-      await writeFile(sharedPath, sharedDataStr);
+      this.writeQueue.enqueue({writePromise: writeFile(sharedPath, sharedDataStr)});
     }
   }
 
@@ -892,9 +933,13 @@ export default class I3SConverter {
 
           if (this.generateTextures) {
             formats.push({name: '1', format: 'ktx2'});
-            const ktx2TextureData = new Uint8Array(
-              await encode(texture.image, KTX2BasisUniversalTextureWriter)
-            );
+            const ktx2TextureData = encode(texture.image, KTX2BasisWriterWorker, {
+              ...KTX2BasisWriterWorker.options,
+              source: this.workerSource.ktx2,
+              reuseWorkers: true,
+              _nodeWorkers: true
+            });
+
             await this.writeTextureFile(ktx2TextureData, '1', 'ktx2', childPath, slpkChildPath);
           }
 
@@ -907,9 +952,7 @@ export default class I3SConverter {
 
           if (this.generateTextures) {
             formats.push({name: '0', format: 'jpg'});
-            const decodedFromKTX2TextureData = new Uint8Array(
-              await encode(texture.image!.data[0], ImageWriter)
-            );
+            const decodedFromKTX2TextureData = encode(texture.image!.data[0], ImageWriter);
             await this.writeTextureFile(
               decodedFromKTX2TextureData,
               '0',
@@ -936,7 +979,7 @@ export default class I3SConverter {
    * @param slpkChildPath
    */
   private async writeTextureFile(
-    textureData: ArrayBuffer,
+    textureData: Promise<ArrayBuffer>,
     name: string,
     format: 'jpg' | 'png' | 'ktx2',
     childPath: string,
@@ -946,15 +989,15 @@ export default class I3SConverter {
       const slpkTexturePath = join(childPath, 'textures');
       const compress = false;
 
-      this.fileMap[`${slpkChildPath}/textures/${name}.${format}`] = await writeFileForSlpk(
-        slpkTexturePath,
-        textureData,
-        `${name}.${format}`,
-        compress
-      );
+      this.writeQueue.enqueue({
+        archiveKey: `${slpkChildPath}/textures/${name}.${format}`,
+        writePromise: writeFileForSlpk(slpkTexturePath, textureData, `${name}.${format}`, compress)
+      });
     } else {
       const texturePath = join(childPath, `textures/${name}/`);
-      await writeFile(texturePath, textureData, `index.${format}`);
+      this.writeQueue.enqueue({
+        writePromise: writeFile(texturePath, textureData, `index.${format}`)
+      });
     }
   }
 
@@ -965,25 +1008,26 @@ export default class I3SConverter {
    * @param slpkChildPath - the resource path inside *slpk file
    */
   private async _writeAttributes(
-    attributes: ArrayBuffer[],
+    attributes: ArrayBuffer[] | null = [],
     childPath: string,
     slpkChildPath: string
   ): Promise<void> {
-    if (attributes.length && this.layers0?.attributeStorageInfo?.length) {
+    if (attributes?.length && this.layers0?.attributeStorageInfo?.length) {
       for (let index = 0; index < attributes.length; index++) {
         const folderName = this.layers0.attributeStorageInfo[index].key;
         const fileBuffer = new Uint8Array(attributes[index]);
 
         if (this.options.slpk) {
           const slpkAttributesPath = join(childPath, 'attributes', folderName);
-          this.fileMap[`${slpkChildPath}/attributes/${folderName}.bin.gz`] = await writeFileForSlpk(
-            slpkAttributesPath,
-            fileBuffer,
-            '0.bin'
-          );
+          this.writeQueue.enqueue({
+            archiveKey: `${slpkChildPath}/attributes/${folderName}.bin.gz`,
+            writePromise: writeFileForSlpk(slpkAttributesPath, fileBuffer, '0.bin')
+          });
         } else {
           const attributesPath = join(childPath, `attributes/${folderName}/0`);
-          await writeFile(attributesPath, fileBuffer, 'index.bin');
+          this.writeQueue.enqueue({
+            writePromise: writeFile(attributesPath, fileBuffer, 'index.bin')
+          });
         }
       }
     }
@@ -1297,4 +1341,27 @@ export default class I3SConverter {
   private isContentSupported(sourceRootTile: Tile3D): boolean {
     return ['b3dm', 'glTF'].includes(sourceRootTile?.content?.type);
   }
+
+  private async loadWorkers(): Promise<void> {
+    console.log(`Loading workers source...`); // eslint-disable-line no-undef, no-console
+    if (this.options.draco) {
+      const url = getWorkerURL(DracoWriterWorker, {...getLoaderOptions()});
+      const sourceResponse = await fetchFile(url);
+      const source = await sourceResponse.text();
+      this.workerSource.draco = source;
+    }
+
+    if (this.generateTextures) {
+      const url = getWorkerURL(KTX2BasisWriterWorker, {...getLoaderOptions()});
+      const sourceResponse = await fetchFile(url);
+      const source = await sourceResponse.text();
+      this.workerSource.ktx2 = source;
+    }
+
+    const i3sAttributesWorkerUrl = getWorkerURL(I3SAttributesWorker, {...getLoaderOptions()});
+    const sourceResponse = await fetchFile(i3sAttributesWorkerUrl);
+    const source = await sourceResponse.text();
+    this.workerSource.I3SAttributes = source;
+    console.log(`Loading workers source completed!`); // eslint-disable-line no-undef, no-console
+  }
 }