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

package/dist/lib/utils/compress-util.js

@@ -0,0 +1,190 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addFileToZip = exports.generateHash128FromZip = exports.compressWithChildProcess = exports.compressFilesWithZip = exports.compressFileWithGzip = void 0;
+const zlib_1 = require("zlib");
+const path_1 = require("path");
+const fs_1 = require("fs");
+const archiver_1 = __importDefault(require("archiver"));
+const file_utils_1 = require("./file-utils");
+const worker_utils_1 = require("@loaders.gl/worker-utils");
+const jszip_1 = __importDefault(require("jszip"));
+const crypto_1 = require("@loaders.gl/crypto");
+const crypt_1 = __importDefault(require("crypt"));
+const file_utils_2 = require("./file-utils");
+function compressFileWithGzip(pathFile) {
+    const compressedPathFile = `${pathFile}.gz`;
+    const gzip = (0, zlib_1.createGzip)();
+    const input = (0, fs_1.createReadStream)(pathFile);
+    const output = (0, fs_1.createWriteStream)(compressedPathFile);
+    return new Promise((resolve, reject) => {
+        input.on('end', () => {
+            console.log(`${compressedPathFile} compressed and saved.`); // eslint-disable-line no-undef,no-console
+            resolve(compressedPathFile);
+        });
+        input.on('error', (error) => {
+            console.log(`${compressedPathFile}: compression error!`); // eslint-disable-line no-undef,no-console
+            reject(error);
+        });
+        input.pipe(gzip).pipe(output);
+    });
+}
+exports.compressFileWithGzip = compressFileWithGzip;
+async function compressFilesWithZip(fileMap, outputFile, level = 0) {
+    // Before creating a new file, we need to delete the old file
+    try {
+        await (0, file_utils_1.removeFile)(outputFile);
+    }
+    catch (e) {
+        // Do nothing if old file doesn't exist
+    }
+    const output = (0, fs_1.createWriteStream)(outputFile);
+    const archive = (0, archiver_1.default)('zip', {
+        zlib: { level } // Sets the compression level.
+    });
+    return new Promise(async (resolve, reject) => {
+        // listen for all archive data to be writte
+        // 'close' event is fired only when a file descriptor is involved
+        output.on('close', function () {
+            console.log(`${outputFile} saved.`); // eslint-disable-line no-undef,no-console
+            console.log(`${archive.pointer()} total bytes`); // eslint-disable-line no-undef,no-console
+            resolve(null);
+        });
+        // This event is fired when the data source is drained no matter what was the data source.
+        // It is not part of this library but rather from the NodeJS Stream API.
+        // @see: https://nodejs.org/api/stream.html#stream_event_end
+        output.on('end', function () {
+            console.log('Data has been drained'); // eslint-disable-line no-undef,no-console
+            resolve(null);
+        });
+        // good practice to catch warnings (ie stat failures and other non-blocking errors)
+        archive.on('warning', function (err) {
+            console.log(err); // eslint-disable-line no-undef,no-console
+            reject(err);
+        });
+        // good practice to catch this error explicitly
+        archive.on('error', function (err) {
+            reject(err);
+        });
+        // pipe archive data to the file
+        archive.pipe(output);
+        for (const subFileName in fileMap) {
+            const subFileData = fileMap[subFileName];
+            await appendFileToArchive(archive, subFileName, subFileData);
+        }
+        // finalize the archive (ie we are done appending files but streams have to finish yet)
+        archive.finalize();
+    });
+}
+exports.compressFilesWithZip = compressFilesWithZip;
+async function compressWithChildProcess() {
+    // eslint-disable-next-line no-undef
+    if (process.platform === 'win32') {
+        await compressWithChildProcessWindows(...arguments);
+    }
+    else {
+        await compressWithChildProcessUnix(...arguments);
+    }
+}
+exports.compressWithChildProcess = compressWithChildProcess;
+async function compressWithChildProcessUnix(inputFolder, outputFile, level = 0, inputFiles = '.') {
+    const fullOutputFile = (0, file_utils_2.getAbsoluteFilePath)(outputFile);
+    const args = [`-${level}`, '-r', fullOutputFile, inputFiles];
+    const childProcess = new worker_utils_1.ChildProcessProxy();
+    await childProcess.start({
+        command: 'zip',
+        arguments: args,
+        spawn: {
+            cwd: inputFolder
+        },
+        wait: 0
+    });
+}
+async function compressWithChildProcessWindows(inputFolder, outputFile, level = 0, inputFiles = (0, path_1.join)('.', '*'), sevenZipExe) {
+    // Workaround for @listfile issue. In 7z.exe @-leading files are handled as listfiles
+    // https://sevenzip.osdn.jp/chm/cmdline/syntax.htm
+    if (inputFiles[0] === '@') {
+        inputFiles = `*${inputFiles.substr(1)}`;
+    }
+    const fullOutputFile = (0, file_utils_2.getAbsoluteFilePath)(outputFile);
+    const args = ['a', '-tzip', `-mx=${level}`, fullOutputFile, inputFiles];
+    const childProcess = new worker_utils_1.ChildProcessProxy();
+    await childProcess.start({
+        command: sevenZipExe,
+        arguments: args,
+        spawn: {
+            cwd: `${inputFolder}`
+        },
+        wait: 0
+    });
+}
+async function generateHash128FromZip(inputZipFile, outputFile) {
+    const input = await fs_1.promises.readFile(inputZipFile);
+    const zip = await jszip_1.default.loadAsync(input);
+    const hashTable = [];
+    const zipFiles = zip.files;
+    for (const relativePath in zipFiles) {
+        const zipEntry = zipFiles[relativePath];
+        // Had to use a workaround because the correct string is getting the wrong data
+        // const content = await zipEntry.async('nodebuffer');
+        // _data isn't described in the interface, so lint thought it was wrong
+        const _data = '_data';
+        const content = zipEntry[_data].compressedContent;
+        if (zipEntry.dir)
+            continue; // eslint-disable-line no-continue
+        // eslint-disable-next-line no-undef
+        const hash = await new crypto_1.MD5Hash().hash(Buffer.from(relativePath.toLowerCase()));
+        // eslint-disable-next-line no-undef
+        hashTable.push({ key: atob(hash), value: content.byteOffset });
+    }
+    hashTable.sort((prev, next) => {
+        if (prev.key === next.key) {
+            return prev.value < next.value ? -1 : 1;
+        }
+        return prev.key < next.key ? -1 : 1;
+    });
+    const output = (0, fs_1.createWriteStream)(outputFile);
+    return new Promise((resolve, reject) => {
+        output.on('close', function () {
+            console.log(`${outputFile} generated and saved`); // eslint-disable-line
+            resolve(null);
+        });
+        output.on('error', function (err) {
+            console.log(err); // eslint-disable-line
+            reject(err);
+        });
+        for (const key in hashTable) {
+            const item = hashTable[key];
+            const value = _longToByteArray(item.value);
+            // TODO: perhaps you need to wait for the 'drain' event if the write returns 'false'
+            // eslint-disable-next-line no-undef
+            output.write(Buffer.from(crypt_1.default.hexToBytes(item.key).concat(value)));
+        }
+        output.close();
+    });
+}
+exports.generateHash128FromZip = generateHash128FromZip;
+function _longToByteArray(long) {
+    const buffer = new ArrayBuffer(8); // JS numbers are 8 bytes long, or 64 bits
+    const longNum = new Float64Array(buffer); // so equivalent to Float64
+    longNum[0] = long;
+    return Array.from(new Uint8Array(buffer)).reverse(); // reverse to get little endian
+}
+async function addFileToZip(inputFolder, fileName, zipFile, sevenZipExe) {
+    await compressWithChildProcess(inputFolder, zipFile, 0, fileName, sevenZipExe);
+    console.log(`${fileName} added to ${zipFile}.`); // eslint-disable-line
+}
+exports.addFileToZip = addFileToZip;
+function appendFileToArchive(archive, subFileName, subFileData) {
+    return new Promise((resolve) => {
+        const fileStream = (0, fs_1.createReadStream)(subFileData);
+        console.log(`Compression start: ${subFileName}`); // eslint-disable-line no-undef,no-console
+        fileStream.on('close', () => {
+            console.log(`Compression finish: ${subFileName}`); // eslint-disable-line no-undef,no-console
+            resolve(null);
+        });
+        archive.append(fileStream, { name: subFileName });
+    });
+}

package/dist/lib/utils/file-utils.d.ts

@@ -0,0 +1,6 @@
+export function writeFile(path: any, data: any, fileName?: string): Promise<string>;
+export function writeFileForSlpk(path: any, data: any, fileName?: string, compress?: boolean): Promise<string>;
+export function removeDir(path: any): Promise<void>;
+export function removeFile(path: any): Promise<void>;
+export function getAbsoluteFilePath(filePath: any): any;
+//# sourceMappingURL=file-utils.d.ts.map

package/dist/lib/utils/file-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-utils.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/file-utils.js"],"names":[],"mappings":"AAIA,oFAUC;AAED,+GASC;AAED,oDAEC;AAED,qDAEC;AAED,wDAEC"}

package/dist/lib/utils/file-utils.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAbsoluteFilePath = exports.removeFile = exports.removeDir = exports.writeFileForSlpk = exports.writeFile = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const compress_util_1 = require("./compress-util");
+async function writeFile(path, data, fileName = 'index.json') {
+    await fs_1.promises.mkdir(path, { recursive: true });
+    const pathFile = (0, path_1.join)(path, fileName);
+    try {
+        await fs_1.promises.writeFile(pathFile, data);
+    }
+    catch (err) {
+        throw err;
+    }
+    console.log(`${pathFile} saved.`); // eslint-disable-line
+    return pathFile;
+}
+exports.writeFile = writeFile;
+async function writeFileForSlpk(path, data, fileName = 'index.json', compress = true) {
+    const pathFile = await writeFile(path, data, fileName);
+    if (compress) {
+        const pathGzFile = await (0, compress_util_1.compressFileWithGzip)(pathFile);
+        // After compression, we don't need an uncompressed file
+        await removeFile(pathFile);
+        return pathGzFile;
+    }
+    return pathFile;
+}
+exports.writeFileForSlpk = writeFileForSlpk;
+function removeDir(path) {
+    return fs_1.promises.rmdir(path, { recursive: true });
+}
+exports.removeDir = removeDir;
+function removeFile(path) {
+    return fs_1.promises.unlink(path);
+}
+exports.removeFile = removeFile;
+function getAbsoluteFilePath(filePath) {
+    return (0, path_1.isAbsolute)(filePath) ? filePath : (0, path_1.join)(process.cwd(), filePath); // eslint-disable-line no-undef
+}
+exports.getAbsoluteFilePath = getAbsoluteFilePath;

package/dist/lib/utils/lod-conversion-utils.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Do conversion from geometric error to screen threshold
+ * @param {Object} tile
+ * @param {Object} coordinates
+ * In 3DTiles we have HLOD logic and parent tile also has bigger lodMetric value then its children.
+ * In I3s we have reverse logic related to maxError. Parent has lower maxError than its child.
+ * In nodes where are no children tile.lodMetricValue is 0. This is because of logic of HLOD in 3DTiles
+ * 3DTiles spec:
+ * https://github.com/CesiumGS/3d-tiles/tree/master/specification#geometric-error
+ * I3S spec:
+ * https://github.com/Esri/i3s-spec/blob/master/docs/1.7/lodSelection.cmn.md
+ * To avoid infinity values when we do calculations of maxError we shold replace 0 with value which allows us
+ * to make child maxError bigger than his parent maxError.
+ */
+export function convertGeometricErrorToScreenThreshold(tile: any, coordinates: any): {
+    metricType: string;
+    maxError: number;
+}[];
+export function convertScreenThresholdToGeometricError(node: any): number;
+//# sourceMappingURL=lod-conversion-utils.d.ts.map

package/dist/lib/utils/lod-conversion-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lod-conversion-utils.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/lod-conversion-utils.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH;;;IAsBC;AAED,0EAeC"}

package/dist/lib/utils/lod-conversion-utils.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertScreenThresholdToGeometricError = exports.convertGeometricErrorToScreenThreshold = void 0;
+// https://cesium.com/docs/cesiumjs-ref-doc/Cesium3DTileset.html
+const DEFAULT_MAXIMUM_SCREEN_SPACE_ERROR = 16;
+/**
+ * Do conversion from geometric error to screen threshold
+ * @param {Object} tile
+ * @param {Object} coordinates
+ * In 3DTiles we have HLOD logic and parent tile also has bigger lodMetric value then its children.
+ * In I3s we have reverse logic related to maxError. Parent has lower maxError than its child.
+ * In nodes where are no children tile.lodMetricValue is 0. This is because of logic of HLOD in 3DTiles
+ * 3DTiles spec:
+ * https://github.com/CesiumGS/3d-tiles/tree/master/specification#geometric-error
+ * I3S spec:
+ * https://github.com/Esri/i3s-spec/blob/master/docs/1.7/lodSelection.cmn.md
+ * To avoid infinity values when we do calculations of maxError we shold replace 0 with value which allows us
+ * to make child maxError bigger than his parent maxError.
+ */
+function convertGeometricErrorToScreenThreshold(tile, coordinates) {
+    const lodSelection = [];
+    const boundingVolume = tile.boundingVolume;
+    const lodMetricValue = tile.lodMetricValue || 0.1;
+    const maxScreenThreshold = {
+        metricType: 'maxScreenThreshold',
+        maxError: (coordinates.mbs[3] * 2 * DEFAULT_MAXIMUM_SCREEN_SPACE_ERROR) / lodMetricValue
+    };
+    const maxScreenThresholdSQ = {
+        metricType: 'maxScreenThresholdSQ',
+        maxError: Math.PI * 0.25 * maxScreenThreshold.maxError * maxScreenThreshold.maxError
+    };
+    if (boundingVolume.constructor.name === 'OrientedBoundingBox') {
+        lodSelection.push(maxScreenThresholdSQ);
+        lodSelection.push(maxScreenThreshold);
+    }
+    else {
+        lodSelection.push(maxScreenThreshold);
+        lodSelection.push(maxScreenThresholdSQ);
+    }
+    return lodSelection;
+}
+exports.convertGeometricErrorToScreenThreshold = convertGeometricErrorToScreenThreshold;
+function convertScreenThresholdToGeometricError(node) {
+    const metricData = node.header.lodSelection.maxScreenThreshold || {};
+    let maxError = metricData.maxError;
+    if (!maxError) {
+        const sqMetricData = node.header.lodSelection.maxScreenThresholdSQ;
+        if (sqMetricData) {
+            maxError = Math.sqrt(sqMetricData.maxError / (Math.PI * 0.25));
+        }
+    }
+    if (!maxError) {
+        maxError = DEFAULT_MAXIMUM_SCREEN_SPACE_ERROR;
+    }
+    return (node.header.mbs[3] * 2 * DEFAULT_MAXIMUM_SCREEN_SPACE_ERROR) / maxError;
+}
+exports.convertScreenThresholdToGeometricError = convertScreenThresholdToGeometricError;

package/dist/lib/utils/statistic-utills.d.ts

@@ -0,0 +1,3 @@
+export function timeConverter(time: any): string;
+export function calculateFilesSize(params: any): Promise<number | null>;
+//# sourceMappingURL=statistic-utills.d.ts.map

package/dist/lib/utils/statistic-utills.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"statistic-utills.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/statistic-utills.js"],"names":[],"mappings":"AAIA,iDA4BC;AAED,wEAkBC"}

package/dist/lib/utils/statistic-utills.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateFilesSize = exports.timeConverter = void 0;
+const path_1 = require("path");
+const fs_1 = require("fs");
+const file_utils_1 = require("./file-utils");
+function timeConverter(time) {
+    const nanoSecondsInMillisecond = 1e6;
+    let timeInSeconds = time[0];
+    const hours = Math.floor(timeInSeconds / 3600);
+    timeInSeconds = timeInSeconds - hours * 3600;
+    const minutes = Math.floor(timeInSeconds / 60);
+    timeInSeconds = timeInSeconds - minutes * 60;
+    const seconds = Math.floor(timeInSeconds);
+    const milliseconds = time[1] / nanoSecondsInMillisecond;
+    let result = '';
+    if (hours) {
+        result += `${hours}h `;
+    }
+    if (minutes) {
+        result += `${minutes}m `;
+    }
+    if (seconds) {
+        result += `${seconds}s`;
+    }
+    if (!result) {
+        result += `${milliseconds}ms`;
+    }
+    return result;
+}
+exports.timeConverter = timeConverter;
+async function calculateFilesSize(params) {
+    const { slpk, outputPath, tilesetName } = params;
+    const fullOutputPath = (0, file_utils_1.getAbsoluteFilePath)(outputPath);
+    try {
+        if (slpk) {
+            const slpkPath = (0, path_1.join)(fullOutputPath, `${tilesetName}.slpk`);
+            const stat = await fs_1.promises.stat(slpkPath);
+            return stat.size;
+        }
+        const directoryPath = (0, path_1.join)(fullOutputPath, tilesetName);
+        const totalSize = await getTotalFilesSize(directoryPath);
+        return totalSize;
+    }
+    catch (error) {
+        console.log('Calculate file sizes error: ', error); // eslint-disable-line
+        return null;
+    }
+}
+exports.calculateFilesSize = calculateFilesSize;
+async function getTotalFilesSize(dirPath) {
+    let totalFileSize = 0;
+    const files = await fs_1.promises.readdir(dirPath);
+    for (const file of files) {
+        const fileStat = await fs_1.promises.stat((0, path_1.join)(dirPath, file));
+        if (fileStat.isDirectory()) {
+            totalFileSize += await getTotalFilesSize((0, path_1.join)(dirPath, file));
+        }
+        else {
+            totalFileSize += fileStat.size;
+        }
+    }
+    return totalFileSize;
+}

package/dist/pgm-loader.d.ts

@@ -0,0 +1,6 @@
+import type { LoaderWithParser } from '@loaders.gl/loader-utils';
+/**
+ * Loader for PGM - Netpbm grayscale image format
+ */
+export declare const PGMLoader: LoaderWithParser;
+//# sourceMappingURL=pgm-loader.d.ts.map

package/dist/pgm-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pgm-loader.d.ts","sourceRoot":"","sources":["../src/pgm-loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAQ/D;;GAEG;AACH,eAAO,MAAM,SAAS,EAAE,gBAYvB,CAAC"}

package/dist/pgm-loader.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PGMLoader = void 0;
+// __VERSION__ is injected by babel-plugin-version-inline
+// @ts-ignore TS2304: Cannot find name '__VERSION__'.
+const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
+const geoid_1 = require("@math.gl/geoid");
+/**
+ * Loader for PGM - Netpbm grayscale image format
+ */
+exports.PGMLoader = {
+    name: 'PGM - Netpbm grayscale image format',
+    id: 'pgm',
+    module: 'tile-converter',
+    version: VERSION,
+    mimeTypes: ['image/x-portable-graymap'],
+    parse: async (arrayBuffer, options) => (0, geoid_1.parsePGM)(new Uint8Array(arrayBuffer), options),
+    extensions: ['pgm'],
+    options: {
+        // TODO - use pgm namespace
+        cubic: false
+    }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loaders.gl/tile-converter",
-  "version": "3.1.8",
+  "version": "3.2.0-alpha.1",
   "description": "Converter",
   "license": "MIT",
   "publishConfig": {
@@ -33,25 +33,24 @@
     "fs": false
   },
   "scripts": {
-    "pre-build": "npm run build-bundle",
-    "post-build": "npm run build-converter-bundle",
+    "pre-build": "npm run build-bundle  && npm run build-converter-bundle",
     "build-bundle": "esbuild ./src/index.ts --bundle --outfile=dist/dist.min.js --platform=node",
     "build-converter-bundle": "webpack --display errors-only --config ./converter-webpack/bundle.js",
     "build-bin": "BABEL_ENV=es5 babel scripts --config-file ../../babel.config.js --out-dir dist/scripts"
   },
   "dependencies": {
-    "@loaders.gl/3d-tiles": "3.1.8",
-    "@loaders.gl/crypto": "3.1.8",
-    "@loaders.gl/draco": "3.1.8",
-    "@loaders.gl/gltf": "3.1.8",
-    "@loaders.gl/i3s": "3.1.8",
-    "@loaders.gl/images": "3.1.8",
-    "@loaders.gl/loader-utils": "3.1.8",
-    "@loaders.gl/polyfills": "3.1.8",
-    "@loaders.gl/textures": "3.1.8",
-    "@loaders.gl/tiles": "3.1.8",
-    "@loaders.gl/worker-utils": "3.1.8",
-    "@loaders.gl/zip": "3.1.8",
+    "@loaders.gl/3d-tiles": "3.2.0-alpha.1",
+    "@loaders.gl/crypto": "3.2.0-alpha.1",
+    "@loaders.gl/draco": "3.2.0-alpha.1",
+    "@loaders.gl/gltf": "3.2.0-alpha.1",
+    "@loaders.gl/i3s": "3.2.0-alpha.1",
+    "@loaders.gl/images": "3.2.0-alpha.1",
+    "@loaders.gl/loader-utils": "3.2.0-alpha.1",
+    "@loaders.gl/polyfills": "3.2.0-alpha.1",
+    "@loaders.gl/textures": "3.2.0-alpha.1",
+    "@loaders.gl/tiles": "3.2.0-alpha.1",
+    "@loaders.gl/worker-utils": "3.2.0-alpha.1",
+    "@loaders.gl/zip": "3.2.0-alpha.1",
     "@luma.gl/engine": "^8.5.4",
     "@math.gl/core": "^3.5.1",
     "@math.gl/culling": "^3.5.1",
@@ -69,7 +68,7 @@
     "uuid": "^8.1.0"
   },
   "peerDependencies": {
-    "@loaders.gl/core": "^3.1.0"
+    "@loaders.gl/core": "4.0.0-alpha.4"
   },
-  "gitHead": "0ef07b4e9fc20f5a882224cf241c6fd1bad898d8"
+  "gitHead": "423a2815092b08dcf93ad5b7dc2940b167305afe"
 }

package/src/3d-tiles-converter/3d-tiles-converter.ts

@@ -67,8 +67,11 @@ export default class Tiles3DConverter {
     console.log('Loading egm file completed!'); // eslint-disable-line
 
     const sourceTilesetJson = await load(inputUrl, I3SLoader, {});
+
     this.sourceTileset = new Tileset3D(sourceTilesetJson, {
-      loadOptions: {i3s: {coordinateSystem: COORDINATE_SYSTEM.LNGLAT_OFFSETS}}
+      loadOptions: {
+        i3s: {coordinateSystem: COORDINATE_SYSTEM.LNGLAT_OFFSETS, decodeTextures: false}
+      }
     });
 
     const rootNode = this.sourceTileset.root!;

package/src/3d-tiles-converter/helpers/b3dm-converter.ts

@@ -1,7 +1,6 @@
-import {encode, encodeSync} from '@loaders.gl/core';
+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';
@@ -81,7 +80,8 @@ export default class B3dmConverter {
     const meshIndex = gltfBuilder.addMesh({
       attributes,
       indices,
-      material: materialIndex
+      material: materialIndex,
+      mode: 4
     });
     const transformMatrix = this._generateTransformMatrix(cartesianOrigin);
     const nodeIndex = gltfBuilder.addNode({meshIndex, matrix: transformMatrix});
@@ -116,8 +116,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;
     }
@@ -210,6 +209,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/i3s-converter/i3s-converter.ts

@@ -96,6 +96,7 @@ export default class I3SConverter {
   Loader: LoaderWithParser = Tiles3DLoader;
   generateTextures: boolean;
   generateBoundingVolumes: boolean;
+  layersHasTexture: boolean;
 
   constructor() {
     this.nodePages = new NodePages(writeFile, HARDCODED_NODES_PER_PAGE);
@@ -114,6 +115,7 @@ export default class I3SConverter {
     this.validate = false;
     this.generateTextures = false;
     this.generateBoundingVolumes = false;
+    this.layersHasTexture = false;
   }
 
   /**
@@ -226,6 +228,14 @@ 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'));
@@ -556,6 +566,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;
       }