@loaders.gl/tile-converter 4.0.0-alpha.1 → 4.0.0-alpha.11

package/src/3d-tiles-converter/helpers/{b3dm-converter.js → b3dm-converter.ts}

@@ -1,41 +1,67 @@
-import {encode, encodeSync} from '@loaders.gl/core';
+import type {I3SAttributesData} from '../../3d-tiles-attributes-worker';
+
+import {encodeSync} from '@loaders.gl/core';
 import {GLTFScenegraph, GLTFWriter} from '@loaders.gl/gltf';
 import {Tile3DWriter} from '@loaders.gl/3d-tiles';
-import {ImageWriter} from '@loaders.gl/images';
 import {Matrix4, Vector3} from '@math.gl/core';
 import {Ellipsoid} from '@math.gl/geospatial';
 import {convertTextureAtlas} from './texture-atlas';
+import {generateSyntheticIndices} from '../../lib/utils/geometry-utils';
 
 const Z_UP_TO_Y_UP_MATRIX = new Matrix4([1, 0, 0, 0, 0, 0, -1, 0, 0, 1, 0, 0, 0, 0, 0, 1]);
 const scratchVector = new Vector3();
 
+/**
+ * Converts content of an I3S node to *.b3dm's file content
+ */
 export default class B3dmConverter {
-  async convert(i3sTile, attributes = null) {
-    this.i3sTile = i3sTile;
-    const gltf = await this.buildGltf(i3sTile);
+  // @ts-expect-error
+  rtcCenter: Float32Array;
+  i3sTile: any;
+
+  /**
+   * The starter of content conversion
+   * @param i3sTile - Tile3D instance for I3S node
+   * @returns - encoded content
+   */
+  async convert(
+    i3sAttributesData: I3SAttributesData,
+    featureAttributes: any = null
+  ): Promise<ArrayBuffer> {
+    const gltf = await this.buildGltf(i3sAttributesData, featureAttributes);
     const b3dm = encodeSync(
       {
         gltfEncoded: new Uint8Array(gltf),
         type: 'b3dm',
-        featuresLength: this._getFeaturesLength(attributes),
-        batchTable: attributes
+        featuresLength: this._getFeaturesLength(featureAttributes),
+        batchTable: featureAttributes
       },
       Tile3DWriter
     );
     return b3dm;
   }
 
-  async buildGltf(i3sTile) {
+  /**
+   * Build and encode gltf
+   * @param i3sTile - Tile3D instance for I3S node
+   * @returns - encoded glb content
+   */
+  async buildGltf(
+    i3sAttributesData: I3SAttributesData,
+    featureAttributes: any
+  ): Promise<ArrayBuffer> {
+    const {tileContent, textureFormat} = i3sAttributesData;
     const {
       material,
       attributes,
       indices: originalIndices,
       cartesianOrigin,
-      cartographicOrigin
-    } = i3sTile.content;
+      cartographicOrigin,
+      modelMatrix
+    } = tileContent;
     const gltfBuilder = new GLTFScenegraph();
 
-    const textureIndex = await this._addI3sTextureToGltf(i3sTile, gltfBuilder);
+    const textureIndex = await this._addI3sTextureToGltf(tileContent, textureFormat, gltfBuilder);
     const pbrMaterialInfo = this._convertI3sMaterialToGltfMaterial(material, textureIndex);
     const materialIndex = gltfBuilder.addMaterial(pbrMaterialInfo);
 
@@ -52,17 +78,20 @@ export default class B3dmConverter {
     attributes.positions.value = this._normalizePositions(
       positionsValue,
       cartesianOrigin,
-      cartographicOrigin
+      cartographicOrigin,
+      modelMatrix
     );
+    this._createBatchIds(tileContent, featureAttributes);
     if (attributes.normals && !this._checkNormals(attributes.normals.value)) {
       delete attributes.normals;
     }
     const indices =
-      originalIndices || this._generateSynteticIndices(positionsValue.length / positions.size);
+      originalIndices || generateSyntheticIndices(positionsValue.length / positions.size);
     const meshIndex = gltfBuilder.addMesh({
       attributes,
       indices,
-      material: materialIndex
+      material: materialIndex,
+      mode: 4
     });
     const transformMatrix = this._generateTransformMatrix(cartesianOrigin);
     const nodeIndex = gltfBuilder.addNode({meshIndex, matrix: transformMatrix});
@@ -82,11 +111,8 @@ export default class B3dmConverter {
    * @param {GLTFScenegraph} gltfBuilder - gltfScenegraph instance to construct GLTF
    * @returns {Promise<number | null>} - GLTF texture index
    */
-  async _addI3sTextureToGltf(i3sTile, gltfBuilder) {
-    const {
-      content: {texture, material, attributes},
-      header: {textureFormat}
-    } = i3sTile;
+  async _addI3sTextureToGltf(tileContent, textureFormat, gltfBuilder) {
+    const {texture, material, attributes} = tileContent;
     let textureIndex = null;
     let selectedTexture = texture;
     if (!texture && material) {
@@ -97,8 +123,7 @@ export default class B3dmConverter {
     }
     if (selectedTexture) {
       const mimeType = this._deduceMimeTypeFromFormat(textureFormat);
-      const imageBuffer = await encode(selectedTexture, ImageWriter);
-      const imageIndex = gltfBuilder.addImage(imageBuffer, mimeType);
+      const imageIndex = gltfBuilder.addImage(selectedTexture, mimeType);
       textureIndex = gltfBuilder.addTexture({imageIndex});
       delete attributes.colors;
     }
@@ -109,14 +134,18 @@ export default class B3dmConverter {
    * Generate a positions array which is correct for 3DTiles/GLTF format
    * @param {Float64Array} positionsValue - the input geometry positions array
    * @param {number[]} cartesianOrigin - the tile center in the cartesian coordinate system
+   * @param {number[]} cartographicOrigin - the tile center in the cartographic coordinate system
+   * @param {number[]} modelMatrix - the model matrix of geometry
    * @returns {Float32Array} - the output geometry positions array
    */
-  _normalizePositions(positionsValue, cartesianOrigin, cartographicOrigin) {
+  _normalizePositions(positionsValue, cartesianOrigin, cartographicOrigin, modelMatrix) {
     const newPositionsValue = new Float32Array(positionsValue.length);
     for (let index = 0; index < positionsValue.length; index += 3) {
       const vertex = positionsValue.subarray(index, index + 3);
       const cartesianOriginVector = new Vector3(cartesianOrigin);
-      let vertexVector = new Vector3(Array.from(vertex)).add(cartographicOrigin);
+      let vertexVector = new Vector3(Array.from(vertex))
+        .transform(modelMatrix)
+        .add(cartographicOrigin);
       Ellipsoid.WGS84.cartographicToCartesian(vertexVector, scratchVector);
       vertexVector = scratchVector.subtract(cartesianOriginVector);
       newPositionsValue.set(vertexVector, index);
@@ -139,40 +168,28 @@ export default class B3dmConverter {
   }
 
   /**
-   * Generate batchId attribute from faceRanges.
-   * @param {Uint32Array} faceRanges - the source array
-   * @returns {Float32Array} batchId list.
+   * Create _BATCHID attribute
+   * @param {Object} i3sContent - the source object
+   * @returns {void}
    */
-  _generateBatchId(faceRanges) {
-    const batchIdArraySize = (faceRanges[faceRanges.length - 1] + 1) * 3;
-    const batchId = new Float32Array(batchIdArraySize);
-    let rangeIndex = 0;
-    let currentBatchId = 0;
-
-    for (let index = 0; index < faceRanges.length / 2; index++) {
-      const fromIndex = faceRanges[rangeIndex] * 3;
-      const untilPosition = (faceRanges[rangeIndex + 1] + 1) * 3;
-
-      batchId.fill(currentBatchId, fromIndex, untilPosition);
-      rangeIndex += 2;
-      currentBatchId += 1;
+  _createBatchIds(i3sContent, featureAttributes) {
+    const {featureIds} = i3sContent;
+    const {OBJECTID: objectIds} = featureAttributes || {};
+    if (!featureIds || !objectIds) {
+      return;
     }
-    return batchId;
-  }
 
-  /**
-   * luma.gl can not work without indices now:
-   * https://github.com/visgl/luma.gl/blob/d8cad75b9f8ca3e578cf078ed9d19e619c2ddbc9/modules/experimental/src/gltf/gltf-instantiator.js#L115
-   * This method generates syntetic indices array: [0, 1, 2, 3, .... , vertexCount-1]
-   * @param {number} vertexCount - vertex count in the geometry
-   * @returns {Uint32Array} indices array.
-   */
-  _generateSynteticIndices(vertexCount) {
-    const result = new Uint32Array(vertexCount);
-    for (let index = 0; index < vertexCount; index++) {
-      result.set([index], index);
+    for (let i = 0; i < featureIds.length; i++) {
+      const featureId = featureIds[i];
+      const batchId = objectIds.indexOf(featureId);
+      featureIds[i] = batchId;
     }
-    return result;
+
+    i3sContent.attributes._BATCHID = {
+      size: 1,
+      byteOffset: 0,
+      value: featureIds
+    };
   }
 
   /**
@@ -187,6 +204,8 @@ export default class B3dmConverter {
         return 'image/jpeg';
       case 'png':
         return 'image/png';
+      case 'ktx2':
+        return 'image/ktx2';
       default:
         console.warn(`Unexpected texture format in I3S: ${format}`); // eslint-disable-line no-console, no-undef
         return 'image/jpeg';

package/src/3d-tiles-converter/helpers/{i3s-obb-to-3d-tiles-obb.js → i3s-obb-to-3d-tiles-obb.ts}

@@ -1,8 +1,23 @@
 import {Vector3} from '@math.gl/core';
 import {Ellipsoid} from '@math.gl/geospatial';
 import {OrientedBoundingBox} from '@math.gl/culling';
+// @ts-expect-error
+import {GeoidHeightModel} from '@loaders.gl/tile-converter/lib/geoid-height-model';
 
-export function i3sObbTo3dTilesObb(i3SObb, geoidHeightModel) {
+/**
+ * Convert quaternion-based OBB to half-axes-based OBB
+ * @param i3SObb quaternion based OBB
+ * @param geoidHeightModel the Earth Gravity Model instance
+ * @returns number[12] 3DTiles OBB https://github.com/CesiumGS/3d-tiles/tree/master/specification#box
+ */
+export function i3sObbTo3dTilesObb(
+  i3SObb: {
+    center: number[];
+    halfSize: number[];
+    quaternion: number[];
+  },
+  geoidHeightModel: GeoidHeightModel
+): number[] {
   const tiles3DCenter = [
     i3SObb.center[0],
     i3SObb.center[1],

package/src/3d-tiles-converter/helpers/texture-atlas.ts

@@ -13,7 +13,7 @@ export function convertTextureAtlas(texCoords: Float32Array, uvRegions: Uint16Ar
     const uv = texCoords.subarray(index, index + 2);
     const regions = normalisedRegions.slice(index * 2, index * 2 + 4);
     // fract(texCoords)
-    const fractatedUV = fract(uv);
+    const fractatedUV = fract([uv[0], uv[1]]);
     // (uvRegions.zw - uvRegions.xy)
     const subtracted = [regions[2] - regions[0], regions[3] - regions[1]];
     // fract(texCoords) * (uvRegions.zw - uvRegions.xy)
@@ -35,7 +35,7 @@ export function convertTextureAtlas(texCoords: Float32Array, uvRegions: Uint16Ar
  * Do fractation of UV array.
  * @param uv
  */
-function fract(uv: number[2]): number[2] {
+function fract(uv: [number, number]): [number, number] {
   return [uv[0] - Math.floor(uv[0]), uv[1] - Math.floor(uv[1])];
 }
 
@@ -43,9 +43,9 @@ function fract(uv: number[2]): number[2] {
  * Normalize uvRegions by dividing by the maximum Uint16 value
  * @param regions
  */
-function normalizeRegions(regions: Uint16Array): number[4] {
+function normalizeRegions(regions: Uint16Array): number[] {
   const MAX_UINT_16_VALUE = 65535;
-  const normalizedRegions = [];
+  const normalizedRegions: number[] = [];
 
   for (let index = 0; index < regions.length; index++) {
     normalizedRegions[index] = regions[index] / MAX_UINT_16_VALUE;

package/src/3d-tiles-converter/json-templates/{tileset.js → tileset.ts}

@@ -1,13 +1,13 @@
 import transform from 'json-map-transform';
 
-const ASSET = {
+const ASSET = () => ({
   version: {
     path: 'version',
     default: '1.0'
   }
-};
+});
 
-const TILE = {
+const TILE = () => ({
   boundingVolume: {
     path: 'boundingVolume'
   },
@@ -19,14 +19,14 @@ const TILE = {
   },
   children: {
     path: 'children',
-    transform: (val) => val.map((tile) => transform(tile, TILE))
+    transform: (val) => val.map((tile) => transform(tile, TILE()))
   }
-};
+});
 
-export const TILESET = {
+export const TILESET = () => ({
   asset: {
     path: 'asset',
-    transform: (val) => transform(val, ASSET)
+    transform: (val) => transform(val, ASSET())
   },
   geometricError: {
     path: 'root',
@@ -34,6 +34,6 @@ export const TILESET = {
   },
   root: {
     path: 'root',
-    transform: (val) => transform(val, TILE)
+    transform: (val) => transform(val, TILE())
   }
-};
+});

package/src/constants.ts

@@ -0,0 +1,2 @@
+export const BROWSER_ERROR_MESSAGE =
+  'Tile converter does not work in browser, only in node js environment';

package/src/converter-cli.ts

@@ -0,0 +1,305 @@
+/* eslint-disable no-console */
+import '@loaders.gl/polyfills';
+import {join} from 'path';
+import {I3SConverter, Tiles3DConverter} from '@loaders.gl/tile-converter';
+import {DepsInstaller} from './deps-installer/deps-installer';
+import {
+  getBooleanValue,
+  getIntegerValue,
+  getStringValue,
+  getURLValue,
+  validateOptionsWithEqual
+} from './lib/utils/cli-utils';
+
+type TileConversionOptions = {
+  /** "I3S" - for I3S to 3DTiles conversion, "3DTILES" for 3DTiles to I3S conversion */
+  inputType?: string;
+  /** "tileset.json" file (3DTiles) / "http://..../SceneServer/layers/0" resource (I3S) */
+  tileset?: string;
+  /** Tileset name. This option is used for naming in resulting json resouces and for resulting path/*.slpk file naming */
+  name?: string;
+  /** Output folder. This folder will be created by converter if doesn't exist. It is relative to the converter path.
+   * Default: "data" folder */
+  output: string;
+  /** Keep created 3DNodeIndexDocument files on disk instead of memory. This option reduce memory usage but decelerates conversion speed */
+  instantNodeWriting: boolean;
+  /** Try to merge similar materials to be able to merge meshes into one node (I3S to 3DTiles conversion only) */
+  mergeMaterials: boolean;
+  /** 3DTiles->I3S only. location of 7z.exe archiver to create slpk on Windows OS, default: "C:\Program Files\7-Zip\7z.exe" */
+  sevenZipExe: string;
+  /** location of the Earth Gravity Model (*.pgm) file to convert heights from ellipsoidal to gravity-related format,
+   * default: "./deps/egm2008-5.pgm". A model file can be loaded from GeographicLib
+   * https://geographiclib.sourceforge.io/html/geoid.html */
+  egm: string;
+  /** 3DTile->I3S only. Token for Cesium ION tileset authentication. */
+  token?: string;
+  /** 3DTiles->I3S only. Enable draco compression for geometry. Default: true */
+  draco: boolean;
+  /** Run the script for installing dependencies. Run this options separate from others. Now "*.pgm" file installation is
+   * implemented */
+  installDependencies: boolean;
+  /** 3DTile->I3S only. Enable KTX2 textures generation if only one of (JPG, PNG) texture is provided or generate JPG texture
+   * if only KTX2 is provided */
+  generateTextures: boolean;
+  /** 3DTile->I3S only. Will generate obb and mbs bounding volumes from geometry */
+  generateBoundingVolumes: boolean;
+  /** Validate the dataset during conversion. Validation messages will be posted in the console output */
+  validate: boolean;
+  /** Maximal depth of the hierarchical tiles tree traversal, default: infinite */
+  maxDepth?: number;
+  /** 3DTiles->I3S only. Whether the converter generates *.slpk (Scene Layer Package) I3S output file */
+  slpk: boolean;
+};
+
+/* During validation we check that particular options are defined so they can't be undefined */
+type ValidatedTileConversionOptions = TileConversionOptions & {
+  /** "I3S" - for I3S to 3DTiles conversion, "3DTILES" for 3DTiles to I3S conversion */
+  inputType: string;
+  /** "tileset.json" file (3DTiles) / "http://..../SceneServer/layers/0" resource (I3S) */
+  tileset: string;
+  /** Tileset name. This option is used for naming in resulting json resouces and for resulting path/*.slpk file naming */
+  name: string;
+};
+
+const TILESET_TYPE = {
+  I3S: 'I3S',
+  _3DTILES: '3DTILES'
+};
+
+/**
+ * CLI entry
+ * @returns
+ */
+async function main() {
+  const [, , ...args] = process.argv;
+
+  if (args.length === 0) {
+    printHelp();
+  }
+
+  const validatedOptionsArr = validateOptionsWithEqual(args);
+
+  const options: TileConversionOptions = parseOptions(validatedOptionsArr);
+
+  if (options.installDependencies) {
+    const depthInstaller = new DepsInstaller();
+    depthInstaller.install('deps');
+    return;
+  }
+
+  const validatedOptions: ValidatedTileConversionOptions = validateOptions(options);
+
+  await convert(validatedOptions);
+}
+
+main().catch((error) => {
+  console.log(error);
+  process.exit(1); // eslint-disable-line
+});
+
+/**
+ * Output for `npx tile-converter --help`
+ */
+function printHelp(): void {
+  console.log('cli: converter 3dTiles to I3S or I3S to 3dTiles...');
+  console.log(
+    '--install-dependencies [Run the script for installing dependencies. Run this options separate from others. Now "*.pgm" file installation is implemented]'
+  );
+  console.log(
+    '--max-depth [Maximal depth of hierarchical tiles tree traversal, default: infinite]'
+  );
+  console.log('--name [Tileset name]');
+  console.log('--output [Output folder, default: "data" folder]');
+  console.log(
+    '--instant-node-writing [Keep created 3DNodeIndexDocument files on disk instead of memory. This option reduce memory usage but decelerates conversion speed]'
+  );
+  console.log(
+    '--split-nodes [Prevent to merge similar materials that could lead to incorrect visualization (I3S to 3DTiles conversion only)]'
+  );
+  console.log('--slpk [Generate slpk (Scene Layer Packages) I3S output file]');
+  console.log(
+    '--tileset [tileset.json file (3DTiles) / http://..../SceneServer/layers/0 resource (I3S)]'
+  );
+  console.log('--input-type [tileset input type: I3S or 3DTILES]');
+  console.log(
+    '--7zExe [location of 7z.exe archiver to create slpk on Windows, default: "C:\\Program Files\\7-Zip\\7z.exe"]'
+  );
+  console.log(
+    '--egm [location of Earth Gravity Model *.pgm file to convert heights from ellipsoidal to gravity-related format. A model file can be loaded from GeographicLib https://geographiclib.sourceforge.io/html/geoid.html], default: "./deps/egm2008-5.zip"'
+  );
+  console.log('--token [Token for Cesium ION tilesets authentication]');
+  console.log('--no-draco [Disable draco compression for geometry]');
+  console.log(
+    '--generate-textures [Enable KTX2 textures generation if only one of (JPG, PNG) texture is provided or generate JPG texture if only KTX2 is provided]'
+  );
+  console.log(
+    '--generate-bounding-volumes [Will generate obb and mbs bounding volumes from geometry]'
+  );
+  console.log('--validate [Enable validation]');
+  process.exit(0); // eslint-disable-line
+}
+
+/**
+ * Run conversion process
+ * @param options validated tile-converter options
+ */
+async function convert(options: ValidatedTileConversionOptions) {
+  console.log(`------------------------------------------------`); // eslint-disable-line
+  console.log(`Starting conversion of ${options.inputType}`); // eslint-disable-line
+  console.log(`------------------------------------------------`); // eslint-disable-line
+  const inputType = options.inputType.toUpperCase();
+  switch (inputType) {
+    case TILESET_TYPE.I3S:
+      const tiles3DConverter = new Tiles3DConverter();
+      tiles3DConverter.convert({
+        inputUrl: options.tileset,
+        outputPath: options.output,
+        tilesetName: options.name,
+        maxDepth: options.maxDepth,
+        egmFilePath: options.egm
+      });
+      break;
+    case TILESET_TYPE._3DTILES:
+      const converter = new I3SConverter();
+      await converter.convert({
+        inputUrl: options.tileset,
+        outputPath: options.output,
+        tilesetName: options.name,
+        maxDepth: options.maxDepth,
+        slpk: options.slpk,
+        sevenZipExe: options.sevenZipExe,
+        egmFilePath: options.egm,
+        token: options.token,
+        draco: options.draco,
+        mergeMaterials: options.mergeMaterials,
+        generateTextures: options.generateTextures,
+        generateBoundingVolumes: options.generateBoundingVolumes,
+        validate: options.validate,
+        instantNodeWriting: options.instantNodeWriting
+      });
+      break;
+    default:
+      printHelp();
+  }
+}
+
+// OPTIONS
+/**
+ * Validate input options of the CLI command
+ * @param options - input options of the CLI command
+ * @returns validated options
+ */
+function validateOptions(options: TileConversionOptions): ValidatedTileConversionOptions {
+  const mandatoryOptionsWithExceptions: {
+    [key: string]: () => void;
+  } = {
+    name: () => console.log('Missed: --name [Tileset name]'),
+    output: () => console.log('Missed: --output [Output path name]'),
+    sevenZipExe: () => console.log('Missed: --7zExe [7z archiver executable path]'),
+    egm: () => console.log('Missed: --egm [*.pgm earth gravity model file path]'),
+    tileset: () => console.log('Missed: --tileset [tileset.json file]'),
+    inputType: () =>
+      console.log('Missed/Incorrect: --input-type [tileset input type: I3S or 3DTILES]')
+  };
+  const exceptions: (() => void)[] = [];
+  for (const mandatoryOption in mandatoryOptionsWithExceptions) {
+    const optionValue = options[mandatoryOption];
+    const isWrongInputType =
+      Boolean(optionValue) &&
+      mandatoryOption === 'inputType' &&
+      !Object.values(TILESET_TYPE).includes(optionValue.toUpperCase());
+
+    if (!optionValue || isWrongInputType) {
+      exceptions.push(mandatoryOptionsWithExceptions[mandatoryOption]);
+    }
+  }
+  if (exceptions.length) {
+    exceptions.forEach((exeption) => exeption());
+    process.exit(1);
+  }
+  return <ValidatedTileConversionOptions>options;
+}
+
+/**
+ * Parse option from the cli arguments array
+ * @param args
+ * @returns
+ */
+function parseOptions(args: string[]): TileConversionOptions {
+  const opts: TileConversionOptions = {
+    output: 'data',
+    instantNodeWriting: false,
+    mergeMaterials: true,
+    sevenZipExe: 'C:\\Program Files\\7-Zip\\7z.exe',
+    egm: join(process.cwd(), 'deps', 'egm2008-5.pgm'),
+    draco: true,
+    installDependencies: false,
+    generateTextures: false,
+    generateBoundingVolumes: false,
+    validate: false,
+    slpk: false
+  };
+
+  // eslint-disable-next-line complexity
+  args.forEach((arg, index) => {
+    if (arg.indexOf('--') === 0) {
+      switch (arg) {
+        case '--input-type':
+          opts.inputType = getStringValue(index, args);
+          break;
+        case '--tileset':
+          opts.tileset = getURLValue(index, args);
+          break;
+        case '--name':
+          opts.name = getStringValue(index, args);
+          break;
+        case '--output':
+          opts.output = getStringValue(index, args);
+          break;
+        case '--instant-node-writing':
+          opts.instantNodeWriting = getBooleanValue(index, args);
+          break;
+        case '--split-nodes':
+          opts.mergeMaterials = getBooleanValue(index, args);
+          break;
+        case '--max-depth':
+          opts.maxDepth = getIntegerValue(index, args);
+          break;
+        case '--slpk':
+          opts.slpk = getBooleanValue(index, args);
+          break;
+        case '--7zExe':
+          opts.sevenZipExe = getStringValue(index, args);
+          break;
+        case '--egm':
+          opts.egm = getStringValue(index, args);
+          break;
+        case '--token':
+          opts.token = getStringValue(index, args);
+          break;
+        case '--no-draco':
+          opts.draco = getBooleanValue(index, args);
+          break;
+        case '--validate':
+          opts.validate = getBooleanValue(index, args);
+          break;
+        case '--install-dependencies':
+          opts.installDependencies = getBooleanValue(index, args);
+          break;
+        case '--generate-textures':
+          opts.generateTextures = getBooleanValue(index, args);
+          break;
+        case '--generate-bounding-volumes':
+          opts.generateBoundingVolumes = getBooleanValue(index, args);
+          break;
+        case '--help':
+          printHelp();
+          break;
+        default:
+          console.warn(`Unknown option ${arg}`);
+          process.exit(0); // eslint-disable-line
+      }
+    }
+  });
+  return opts;
+}