@loaders.gl/tile-converter 3.4.6 → 4.0.0-alpha.10

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

@@ -1,7 +1,12 @@
 // loaders.gl, MIT license
 
-import type {Tileset3DProps} from '@loaders.gl/tiles';
-import type {FeatureTableJson} from '@loaders.gl/3d-tiles';
+import type {
+  FeatureTableJson,
+  Tiles3DLoaderOptions,
+  Tiles3DTileContent,
+  Tiles3DTileJSONPostprocessed,
+  Tiles3DTilesetJSONPostprocessed
+} from '@loaders.gl/3d-tiles';
 import type {WriteQueueItem} from '../lib/utils/write-queue';
 import type {
   SceneLayer3D,
@@ -10,7 +15,6 @@ import type {
   NodeInPage
 } from '@loaders.gl/i3s';
 import {load, encode, fetchFile, getLoaderOptions, isBrowser} from '@loaders.gl/core';
-import {Tileset3D} from '@loaders.gl/tiles';
 import {CesiumIonLoader, Tiles3DLoader} from '@loaders.gl/3d-tiles';
 import {Geoid} from '@math.gl/geoid';
 import {join} from 'path';
@@ -41,15 +45,17 @@ import {LAYERS as layersTemplate} from './json-templates/layers';
 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';
-// loaders.gl, MIT license
-
-import {Tile3D} from '@loaders.gl/tiles';
 import {KTX2BasisWriterWorker} from '@loaders.gl/textures';
 import {LoaderWithParser} from '@loaders.gl/loader-utils';
-import {I3SMaterialDefinition, TextureSetDefinitionFormats} from '@loaders.gl/i3s/src/types';
+import {I3SMaterialDefinition, TextureSetDefinitionFormats} from '@loaders.gl/i3s';
 import {ImageWriter} from '@loaders.gl/images';
 import {GLTFImagePostprocessed} from '@loaders.gl/gltf';
-import {I3SConvertedResources, SharedResourcesArrays} from './types';
+import {
+  GltfPrimitiveModeString,
+  I3SConvertedResources,
+  PreprocessData,
+  SharedResourcesArrays
+} from './types';
 import {getWorkerURL, WorkerFarm} from '@loaders.gl/worker-utils';
 import {DracoWriterWorker} from '@loaders.gl/draco';
 import WriteQueue from '../lib/utils/write-queue';
@@ -63,6 +69,12 @@ import {
   getFieldAttributeType
 } from './helpers/feature-attributes';
 import {NodeIndexDocument} from './helpers/node-index-document';
+import {loadNestedTileset, loadTile3DContent} from './helpers/load-3d-tiles';
+import {Matrix4} from '@math.gl/core';
+import {BoundingSphere, OrientedBoundingBox} from '@math.gl/culling';
+import {createBoundingVolume} from '@loaders.gl/tiles';
+import {TraversalConversionProps, traverseDatasetWith} from './helpers/tileset-traversal';
+import {analyzeTileContent, mergePreprocessData} from './helpers/preprocess-3d-tiles';
 
 const ION_DEFAULT_TOKEN =
   process.env?.IonToken || // eslint-disable-line
@@ -96,7 +108,19 @@ export default class I3SConverter {
   boundingVolumeWarnings?: string[] = [];
   conversionStartTime: [number, number] = [0, 0];
   refreshTokenTime: [number, number] = [0, 0];
-  sourceTileset: Tileset3D | null = null;
+  sourceTileset: Tiles3DTilesetJSONPostprocessed | null = null;
+  loadOptions: Tiles3DLoaderOptions = {
+    _nodeWorkers: true,
+    reuseWorkers: true,
+    basis: {
+      format: 'rgba32',
+      // We need to load local fs workers because nodejs can't load workers from the Internet
+      workerUrl: './modules/textures/dist/basis-worker-node.js'
+    },
+    // We need to load local fs workers because nodejs can't load workers from the Internet
+    draco: {workerUrl: './modules/draco/dist/draco-worker-node.js'},
+    fetch: {}
+  };
   geoidHeightModel: Geoid | null = null;
   Loader: LoaderWithParser = Tiles3DLoader;
   generateTextures: boolean;
@@ -105,6 +129,9 @@ export default class I3SConverter {
   workerSource: {[key: string]: string} = {};
   writeQueue: WriteQueue<WriteQueueItem> = new WriteQueue();
   compressList: string[] | null = null;
+  preprocessData: PreprocessData = {
+    meshTopologyTypes: new Set()
+  };
 
   constructor() {
     this.nodePages = new NodePages(writeFile, HARDCODED_NODES_PER_PAGE, this);
@@ -160,7 +187,7 @@ export default class I3SConverter {
     generateTextures?: boolean;
     generateBoundingVolumes?: boolean;
     instantNodeWriting?: boolean;
-  }): Promise<any> {
+  }): Promise<string> {
     if (isBrowser) {
       console.log(BROWSER_ERROR_MESSAGE);
       return BROWSER_ERROR_MESSAGE;
@@ -214,40 +241,86 @@ export default class I3SConverter {
 
     try {
       const preloadOptions = await this._fetchPreloadOptions();
-      const tilesetOptions: Tileset3DProps = {
-        loadOptions: {
-          _nodeWorkers: true,
-          reuseWorkers: true,
-          basis: {format: 'rgba32'},
-          'basis-nodejs': {
-            format: 'rgba32',
-            workerUrl: './modules/textures/dist/basis-nodejs-worker.js'
-          },
-          'draco-nodejs': {workerUrl: './modules/draco/dist/draco-nodejs-worker.js'}
-        }
-      };
       if (preloadOptions.headers) {
-        tilesetOptions.loadOptions!.fetch = {headers: preloadOptions.headers};
+        this.loadOptions.fetch = {headers: preloadOptions.headers};
+      }
+      this.sourceTileset = await load(inputUrl, this.Loader, this.loadOptions);
+
+      const preprocessResult = await this.preprocessConversion();
+
+      if (preprocessResult) {
+        await this._createAndSaveTileset(outputPath, tilesetName);
+        await this._finishConversion({slpk: Boolean(slpk), outputPath, tilesetName});
       }
-      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,
-        sourceTilesetJson?.root?.boundingVolume?.region
-      );
-      await this._finishConversion({slpk: Boolean(slpk), outputPath, tilesetName});
-      return sourceTilesetJson;
     } catch (error) {
       throw error;
     } finally {
+      await this.writeQueue.finalize();
       // Clean up worker pools
       const workerFarm = WorkerFarm.getWorkerFarm({});
       workerFarm.destroy();
     }
+    return 'success';
+  }
+
+  /**
+   * Preprocess stage of the tile converter. Traverse all the tiles tree and
+   * check a tile content to be sure that the data is supported
+   * @returns true - the conversion is possible, false - the tileset's content is not supported
+   */
+  private async preprocessConversion(): Promise<boolean> {
+    console.log(`Analyze source tileset`);
+    const sourceRootTile: Tiles3DTileJSONPostprocessed = this.sourceTileset!.root!;
+    await traverseDatasetWith<null>(
+      sourceRootTile,
+      null,
+      this.analyzeTile.bind(this),
+      undefined,
+      this.options.maxDepth
+    );
+    const {meshTopologyTypes} = this.preprocessData;
+    console.log(`------------------------------------------------`);
+    console.log(`Preprocess results:`);
+    console.log(`glTF mesh topology types: ${Array.from(meshTopologyTypes).join(', ')}`);
+    console.log(`------------------------------------------------`);
+    if (
+      !meshTopologyTypes.has(GltfPrimitiveModeString.TRIANGLES) &&
+      !meshTopologyTypes.has(GltfPrimitiveModeString.TRIANGLE_STRIP)
+    ) {
+      console.log(
+        'The tileset is of unsupported mesh topology types. The conversion will be interrupted.'
+      );
+      console.log(`------------------------------------------------`);
+      return false;
+    }
+    return true;
+  }
+
+  /**
+   * Analyze a tile content. The callback for preprocess stage.
+   * @param sourceTile - 3DTiles tile JSON metadata
+   * @param traversalProps - mandatory argument but it is not used for the preprocess stage
+   * @returns - nothing
+   */
+  private async analyzeTile(
+    sourceTile: Tiles3DTileJSONPostprocessed,
+    traversalProps: null
+  ): Promise<null> {
+    if (sourceTile.type === 'json') {
+      await loadNestedTileset(this.sourceTileset, sourceTile, this.loadOptions);
+      return null;
+    }
+    if (sourceTile.id) {
+      console.log(`[analyze]: ${sourceTile.id}`); // eslint-disable-line
+    }
+    const tileContent = await loadTile3DContent(this.sourceTileset, sourceTile, {
+      ...this.loadOptions,
+      '3d-tiles': {...this.loadOptions['3d-tiles'], loadGLTF: false}
+    });
+    const tilePreprocessData = await analyzeTileContent(sourceTile, tileContent);
+    mergePreprocessData(this.preprocessData, tilePreprocessData);
+
+    return null;
   }
 
   /**
@@ -255,11 +328,7 @@ export default class I3SConverter {
    * @param outputPath - path to save output data
    * @param tilesetName - new tileset path
    */
-  private async _createAndSaveTileset(
-    outputPath: string,
-    tilesetName: string,
-    boundingVolumeRegion?: number[]
-  ): Promise<void> {
+  private async _createAndSaveTileset(outputPath: string, tilesetName: string): Promise<void> {
     const tilesetPath = join(`${outputPath}`, `${tilesetName}`);
     // Removing the tilesetPath needed to exclude erroneous files after conversion
     try {
@@ -270,13 +339,24 @@ export default class I3SConverter {
 
     this.layers0Path = join(tilesetPath, 'SceneServer', 'layers', '0');
 
-    this._formLayers0(tilesetName, boundingVolumeRegion);
-
     this.materialDefinitions = [];
     this.materialMap = new Map();
 
-    const sourceRootTile: Tile3D = this.sourceTileset!.root!;
-    const boundingVolumes = createBoundingVolumes(sourceRootTile, this.geoidHeightModel!);
+    const sourceRootTile: Tiles3DTileJSONPostprocessed = this.sourceTileset!.root!;
+    const sourceBoundingVolume = createBoundingVolume(
+      sourceRootTile.boundingVolume,
+      new Matrix4(sourceRootTile.transform),
+      null
+    );
+
+    this._formLayers0(
+      tilesetName,
+      sourceBoundingVolume,
+      this.sourceTileset?.root?.boundingVolume?.region
+    );
+
+    const boundingVolumes = createBoundingVolumes(sourceBoundingVolume, this.geoidHeightModel!);
+
     await this.nodePages.push({
       index: 0,
       lodThreshold: 0,
@@ -285,7 +365,16 @@ export default class I3SConverter {
     });
 
     const rootNode = await NodeIndexDocument.createRootNode(boundingVolumes, this);
-    await this._convertNodesTree(rootNode, sourceRootTile);
+    await traverseDatasetWith<TraversalConversionProps>(
+      sourceRootTile,
+      {
+        transform: new Matrix4(sourceRootTile.transform),
+        parentNodes: [rootNode]
+      },
+      this.convertTile.bind(this),
+      this.finalizeTile.bind(this),
+      this.options.maxDepth
+    );
 
     this.layers0!.materialDefinitions = this.materialDefinitions;
     // @ts-ignore
@@ -316,12 +405,19 @@ export default class I3SConverter {
 
   /**
    * Form object of 3DSceneLayer https://github.com/Esri/i3s-spec/blob/master/docs/1.7/3DSceneLayer.cmn.md
-   * @param  tilesetName - Name of layer
+   * @param tilesetName - Name of layer
+   * @param sourceBoundingVolume - initialized bounding volume of the source root tile
+   * @param boundingVolumeRegion - region bounding volume of the source root tile
    */
-  private _formLayers0(tilesetName: string, boundingVolumeRegion?: number[]): void {
-    const fullExtent = convertBoundingVolumeToI3SFullExtent(
-      this.sourceTileset?.boundingVolume || this.sourceTileset?.root?.boundingVolume
-    );
+  private _formLayers0(
+    tilesetName: string,
+    sourceBoundingVolume: OrientedBoundingBox | BoundingSphere,
+    boundingVolumeRegion?: number[]
+  ): void {
+    if (!this.sourceTileset?.root) {
+      return;
+    }
+    const fullExtent = convertBoundingVolumeToI3SFullExtent(sourceBoundingVolume);
     if (boundingVolumeRegion) {
       fullExtent.zmin = boundingVolumeRegion[4];
       fullExtent.zmax = boundingVolumeRegion[5];
@@ -345,33 +441,6 @@ export default class I3SConverter {
     this.layers0 = transform(layers0data, layersTemplate());
   }
 
-  /**
-   * Form object of 3DSceneLayer https://github.com/Esri/i3s-spec/blob/master/docs/1.7/3DSceneLayer.cmn.md
-   * @param rootNode - 3DNodeIndexDocument of root node https://github.com/Esri/i3s-spec/blob/master/docs/1.7/3DNodeIndexDocument.cmn.md
-   * @param sourceRootTile - Source (3DTile) tile data
-   */
-  private async _convertNodesTree(
-    rootNode: NodeIndexDocument,
-    sourceRootTile: Tile3D
-  ): Promise<void> {
-    await this.sourceTileset!._loadTile(sourceRootTile);
-    if (this.isContentSupported(sourceRootTile)) {
-      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: rootNode,
-        sourceTiles: sourceRootTile.children,
-        level: 1
-      });
-    }
-    await sourceRootTile.unloadContent();
-    await rootNode.save();
-  }
-
   /**
    * Write 3DSceneLayer https://github.com/Esri/i3s-spec/blob/master/docs/1.7/3DSceneLayer.cmn.md in file
    */
@@ -432,113 +501,90 @@ export default class I3SConverter {
   }
 
   /**
-   * Add child nodes recursively and write them to files
-   * @param data - arguments
-   * @param data.parentNode - 3DNodeIndexDocument of parent node
-   * @param data.sourceTiles - array of source child nodes
-   * @param data.level - level of node (distanse to root node in the tree)
-   */
-  private async _addChildrenWithNeighborsAndWriteFile(data: {
-    parentNode: NodeIndexDocument;
-    sourceTiles: Tile3D[];
-    level: number;
-  }): Promise<void> {
-    await this._addChildren(data);
-    await data.parentNode.addNeighbors();
-  }
-
-  /**
-   * Convert nested subtree of 3DTiles dataset
-   * @param param0
-   * @param data.parentNode - 3DNodeIndexDocument of parent node
-   * @param param0.sourceTile - source 3DTile data
-   * @param param0.level - tree level
+   * Convert the specific 3DTiles tile to I3S nodes.
+   * This is callback function for the traversal generic function
+   * @param sourceTile - current 3DTiles tile JSON metadata
+   * @param traversalProps - traversal properties calculated recursively
+   * @returns - traversal properties for the child tiles
    */
-  private async convertNestedTileset({
-    parentNode,
-    sourceTile,
-    level
-  }: {
-    parentNode: NodeIndexDocument;
-    sourceTile: Tile3D;
-    level: number;
-  }) {
-    await this.sourceTileset!._loadTile(sourceTile);
-    await this._addChildren({
-      parentNode,
-      sourceTiles: sourceTile.children,
-      level: level + 1
-    });
-    await sourceTile.unloadContent();
-  }
+  private async convertTile(
+    sourceTile: Tiles3DTileJSONPostprocessed,
+    traversalProps: TraversalConversionProps
+  ): Promise<TraversalConversionProps> {
+    if (sourceTile.type === 'json' || sourceTile.type === 'empty') {
+      if (sourceTile.type === 'json') {
+        if (sourceTile.id) {
+          console.log(`[load]: ${sourceTile.id}`); // eslint-disable-line
+        }
+        await loadNestedTileset(this.sourceTileset, sourceTile, this.loadOptions);
+      }
+      return traversalProps;
+    }
+    if (sourceTile.id) {
+      console.log(`[convert]: ${sourceTile.id}`); // eslint-disable-line
+    }
 
-  /**
-   * Convert 3DTiles tile to I3S node
-   * @param param0
-   * @param param0.parentNode - 3DNodeIndexDocument of parent node
-   * @param param0.sourceTile - source 3DTile data
-   * @param param0.level - tree level
-   */
-  private async convertNode({
-    parentNode,
-    sourceTile,
-    level
-  }: {
-    parentNode: NodeIndexDocument;
-    sourceTile: Tile3D;
-    level: number;
-  }) {
-    const childNodes = await this._createNode(parentNode, sourceTile, level);
+    const {parentNodes, transform} = traversalProps;
+    let transformationMatrix: Matrix4 = transform.clone();
+    if (sourceTile.transform) {
+      transformationMatrix = transformationMatrix.multiplyRight(sourceTile.transform);
+    }
+    const parentNode = parentNodes[0];
+    const childNodes = await this._createNode(parentNode, sourceTile, transformationMatrix);
     await parentNode.addChildren(childNodes);
+
+    const newTraversalProps: TraversalConversionProps = {
+      transform: transformationMatrix,
+      parentNodes: childNodes
+    };
+    return newTraversalProps;
   }
 
   /**
-   * Add child nodes recursively and write them to files
-   * @param param0 - arguments
-   * @param param0.parentNode - 3DNodeIndexDocument of parent node
-   * @param param0.sourceTile - source 3DTile data
-   * @param param0.level - tree level
+   * Do final action with nodes after the current node and all child nodes been converted.
+   * @param conversionResults - array of conversion results of the current node
+   * @param currentTraversalProps - traversal properties of the current node
    */
-  private async _addChildren(data: {
-    parentNode: NodeIndexDocument;
-    sourceTiles: Tile3D[];
-    level: number;
-  }): Promise<void> {
-    const {sourceTiles, parentNode, level} = data;
-    if (this.options.maxDepth && level > this.options.maxDepth) {
-      return;
-    }
-    for (const sourceTile of sourceTiles) {
-      if (sourceTile.type === 'json') {
-        await this.convertNestedTileset({parentNode, sourceTile, level});
-      } else {
-        await this.convertNode({parentNode, sourceTile, level});
-      }
-      if (sourceTile.id) {
-        console.log(sourceTile.id); // eslint-disable-line
+  private async finalizeTile(
+    conversionResults: TraversalConversionProps[],
+    currentTraversalProps: TraversalConversionProps
+  ): Promise<void> {
+    for (const result of conversionResults) {
+      for (const node of result.parentNodes) {
+        await node.addNeighbors();
       }
     }
+    for (const node of currentTraversalProps.parentNodes) {
+      await node.save();
+    }
   }
 
   /**
    * Convert tile to one or more I3S nodes
    * @param parentNode - 3DNodeIndexDocument of parent node
    * @param sourceTile - source 3DTile data
+   * @param transformationMatrix - transformation matrix of the current tile, calculated recursively multiplying
+   *                               transform of all parent tiles and transform of the current tile
    * @param level - tree level
    */
   private async _createNode(
     parentNode: NodeIndexDocument,
-    sourceTile: Tile3D,
-    level: number
+    sourceTile: Tiles3DTileJSONPostprocessed,
+    transformationMatrix: Matrix4
   ): Promise<NodeIndexDocument[]> {
     this._checkAddRefinementTypeForTile(sourceTile);
 
     await this._updateTilesetOptions();
-    await this.sourceTileset!._loadTile(sourceTile);
 
-    let boundingVolumes = createBoundingVolumes(sourceTile, this.geoidHeightModel!);
+    const tileContent = await loadTile3DContent(this.sourceTileset, sourceTile, this.loadOptions);
+    const sourceBoundingVolume = createBoundingVolume(
+      sourceTile.boundingVolume,
+      transformationMatrix,
+      null
+    );
+    let boundingVolumes = createBoundingVolumes(sourceBoundingVolume, this.geoidHeightModel!);
 
-    const propertyTable = getPropertyTable(sourceTile.content);
+    const propertyTable = getPropertyTable(tileContent);
 
     if (propertyTable && !this.layers0?.attributeStorageInfo?.length) {
       this._convertPropertyTableToNodeAttributes(propertyTable);
@@ -546,6 +592,9 @@ export default class I3SConverter {
 
     const resourcesData = await this._convertResources(
       sourceTile,
+      transformationMatrix,
+      sourceBoundingVolume,
+      tileContent,
       parentNode.inPageId,
       propertyTable
     );
@@ -612,29 +661,29 @@ export default class I3SConverter {
       nodesInPage.push(nodeInPage);
     }
 
-    sourceTile.unloadContent();
-
-    await this._addChildrenWithNeighborsAndWriteFile({
-      parentNode: nodes[0],
-      sourceTiles: sourceTile.children,
-      level: level + 1
-    });
     return nodes;
   }
 
   /**
    * Convert tile to one or more I3S nodes
    * @param sourceTile - source tile (3DTile)
+   * @param transformationMatrix - transformation matrix of the current tile, calculated recursively multiplying
+   *                               transform of all parent tiles and transform of the current tile
+   * @param boundingVolume - initialized bounding volume of the source tile
+   * @param tileContent - content of the source tile
    * @param parentId - id of parent node in node pages
    * @param propertyTable - batch table from b3dm / feature properties from EXT_FEATURE_METADATA
    * @returns - converted node resources
    */
   private async _convertResources(
-    sourceTile: Tile3D,
+    sourceTile: Tiles3DTileJSONPostprocessed,
+    transformationMatrix: Matrix4,
+    boundingVolume: OrientedBoundingBox | BoundingSphere,
+    tileContent: Tiles3DTileContent | null,
     parentId: number,
     propertyTable: FeatureTableJson | null
   ): Promise<I3SConvertedResources[] | null> {
-    if (!this.isContentSupported(sourceTile)) {
+    if (!this.isContentSupported(sourceTile) || !tileContent) {
       return null;
     }
     const draftObb = {
@@ -643,7 +692,9 @@ export default class I3SConverter {
       quaternion: []
     };
     const resourcesData = await convertB3dmToI3sGeometry(
-      sourceTile.content,
+      tileContent,
+      transformationMatrix,
+      boundingVolume,
       async () => (await this.nodePages.push({index: 0, obb: draftObb}, parentId)).index,
       propertyTable,
       this.featuresHashArray,
@@ -675,7 +726,7 @@ export default class I3SConverter {
   private async _updateNodeInNodePages(
     maxScreenThresholdSQ: MaxScreenThresholdSQ,
     boundingVolumes: BoundingVolumes,
-    sourceTile: Tile3D,
+    sourceTile: Tiles3DTileJSONPostprocessed,
     parentId: number,
     resources: I3SConvertedResources
   ): Promise<NodeInPage> {
@@ -910,7 +961,7 @@ export default class I3SConverter {
    * @param slpkChildPath
    */
   private async writeTextureFile(
-    textureData: Promise<ArrayBuffer>,
+    textureData: Uint8Array | Promise<ArrayBuffer>,
     name: string,
     format: 'jpg' | 'png' | 'ktx2',
     childPath: string,
@@ -1095,10 +1146,9 @@ export default class I3SConverter {
     this.refreshTokenTime = process.hrtime();
 
     const preloadOptions = await this._fetchPreloadOptions();
-    this.sourceTileset!.options = {...this.sourceTileset!.options, ...preloadOptions};
     if (preloadOptions.headers) {
-      this.sourceTileset!.loadOptions.fetch = {
-        ...this.sourceTileset!.loadOptions.fetch,
+      this.loadOptions.fetch = {
+        ...this.loadOptions.fetch,
         headers: preloadOptions.headers
       };
       console.log('Authorization Bearer token has been updated'); // eslint-disable-line no-undef, no-console
@@ -1108,7 +1158,7 @@ export default class I3SConverter {
   /** Do calculations of all tiles and tiles with "ADD" type of refinement.
    * @param tile
    */
-  private _checkAddRefinementTypeForTile(tile: Tile3D): void {
+  private _checkAddRefinementTypeForTile(tile: Tiles3DTileJSONPostprocessed): void {
     const ADD_TILE_REFINEMENT = 1;
 
     if (tile.refine === ADD_TILE_REFINEMENT) {
@@ -1118,13 +1168,14 @@ export default class I3SConverter {
 
     this.refinementCounter.tilesCount += 1;
   }
+
   /**
    * Check if the tile's content format is supported by the converter
-   * @param sourceRootTile
+   * @param sourceTile
    * @returns
    */
-  private isContentSupported(sourceRootTile: Tile3D): boolean {
-    return ['b3dm', 'glTF'].includes(sourceRootTile?.content?.type);
+  private isContentSupported(sourceTile: Tiles3DTileJSONPostprocessed): boolean {
+    return ['b3dm', 'glTF', 'scenegraph'].includes(sourceTile.type || '');
   }
 
   private async loadWorkers(): Promise<void> {

package/src/i3s-converter/types.ts

@@ -163,3 +163,23 @@ export type TypedArrayConstructor =
   | Uint32ArrayConstructor
   | Float32ArrayConstructor
   | Float64ArrayConstructor;
+
+/**
+ * glTF primitive modes (mesh topology types)
+ * @see https://registry.khronos.org/glTF/specs/2.0/glTF-2.0.html#_mesh_primitive_mode
+ */
+export enum GltfPrimitiveModeString {
+  POINTS = 'POINTS',
+  LINES = 'LINES',
+  LINE_LOOP = 'LINE_LOOP',
+  LINE_STRIP = 'LINE_STRIP',
+  TRIANGLES = 'TRIANGLES',
+  TRIANGLE_STRIP = 'TRIANGLE_STRIP',
+  TRIANGLE_FAN = 'TRIANGLE_FAN'
+}
+
+/** Preprocessed data gathered from child tiles binary content */
+export type PreprocessData = {
+  /** Mesh topology types used in gltf primitives of the tileset */
+  meshTopologyTypes: Set<GltfPrimitiveModeString>;
+};

package/src/i3s-server/README.md

@@ -0,0 +1,19 @@
+# I3S server
+
+The http server run on NodeJS ExpressJS framework.
+The server provides I3S Rest endpoints per specification https://github.com/Esri/i3s-spec/blob/master/docs/1.7/3Dobject_ReadMe.md#http-api-overview-17
+
+## Usage
+
+### Serve 3DTiles to I3S converted dataset
+
+- Convert data set from 3DTiles to I3S without `--slpk` option
+- Serve output folder `I3sLayerPath="./data/BatchedTextured" DEBUG=i3s-server:* npx i3s-server`
+
+### Serve SLPK
+
+- Serve slpk file `I3sLayerPath="../datasets/Rancho_Mesh_mesh_v17_1.slpk" DEBUG=i3s-server:* npx i3s-server`
+
+## ENV variables
+
+- `I3sLayerPath` - path to converted data or SLPK file.

package/src/i3s-server/app.js

@@ -4,7 +4,9 @@ const logger = require('morgan');
 const cors = require('cors');
 
 const indexRouter = require('./routes/index');
+const {sceneServerRouter, router} = require('./routes/slpk-router');
 
+const I3S_LAYER_PATH = process.env.I3sLayerPath || ''; // eslint-disable-line no-process-env, no-undef
 const app = express();
 
 app.use(logger('dev'));
@@ -13,6 +15,11 @@ app.use(express.urlencoded({extended: false}));
 app.use(express.static(path.join(__dirname, 'public')));
 app.use(cors());
 
-app.use('/', indexRouter);
+if (/\.slpk$/.test(I3S_LAYER_PATH)) {
+  app.use('/SceneServer/layers/0', router);
+  app.use('/SceneServer', sceneServerRouter);
+} else {
+  app.use('/', indexRouter);
+}
 
 module.exports = app;