@needle-tools/gltf-build-pipeline 1.5.0-alpha.9 → 1.6.0-alpha

package/CHANGELOG.md

@@ -4,6 +4,16 @@ All notable changes to this package will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
+## [1.6.0-alpha] - 2023-05-27
+- add: `gltf-build-pipeline` commandline support with `transform` and `compress` (pack-gltf) options.
+
+## [1.5.0-alpha.12] - 2023-05-20
+- add: pack-gltf now also runs `resample` for animations
+- fix: nullreference error in accessing opaque debug options
+
+## [1.5.0-alpha.10] - 2023-05-17
+- add: `generateLods` option to progressive texture settings
+
 ## [1.5.0-alpha.9] - 2023-05-16
 - add: start of VRM 1.0 support. Not implemented is the `VRMC_materials_mtoon` extension 
 

package/dist/cache/cache.d.ts

@@ -1,9 +1,10 @@
 import { ExtensibleProperty } from "@gltf-transform/core";
+import { Logger } from "@donmccurdy/caporal";
 /**
  * Clear the cache.
  * This will remove all files in the cache directory.
  */
-export declare function clearCache(): void;
+export declare function clearCache(logger?: Logger): void;
 /**
  * Ensure that the cache size does not exceed the given maximum size in MB.
  * @param maxSizeMB The maximum size in MB.

package/dist/cache/cache.js

@@ -23,10 +23,13 @@ const buildPipelineVersion = getVersion(false);
  * Clear the cache.
  * This will remove all files in the cache directory.
  */
-export function clearCache() {
+export function clearCache(logger) {
     const dir = getCacheDirectory(true);
     fs.rmSync(dir, { recursive: true });
-    console.log(`Cleared cache at ${dir}`);
+    if (!logger)
+        console.log(`Cleared cache at ${dir}`);
+    else
+        logger.info(`Cleared cache at ${dir}`);
 }
 /**
  * Ensure that the cache size does not exceed the given maximum size in MB.
@@ -223,6 +226,9 @@ function hashObject(obj) {
         const buffer = obj.getArray();
         return hashBuffer(buffer);
     }
+    else if (obj == null) {
+        return 0;
+    }
     const str = JSON.stringify(obj);
     return hashString(str);
 }

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+#! /usr/bin/env node
+export {};

package/dist/cli/index.js

@@ -0,0 +1,102 @@
+#! /usr/bin/env node
+import { program } from '@donmccurdy/caporal';
+import { packGLTF } from "../scripts/index.js";
+import { printStats } from '../utils/stats.js';
+import { getVersion } from '../utils/version.js';
+import { UsecaseOptions, createConfig, getConfig } from '../config/index.js';
+import { make_progressive } from '../transforms/needle_progressive.js';
+import { clearCache } from '../cache/cache.js';
+// For testing / dev you can run `npm link` in the package directory
+// For removing the link run `npm rm --global @needle-tools/gltf-build-pipeline`
+program
+    .command("version", "Print current verison")
+    .action(async ({ logger }) => {
+    logger.info(getVersion());
+})
+    .command("clear-caches", "Clear all caches")
+    .help(`
+Clear all caches.
+`)
+    .action(async ({ logger }) => {
+    logger.info("Clearing caches");
+    clearCache(logger);
+})
+    .command("compress", "Compress a glTF file")
+    .help(`
+Compress a single glTF file. The input file is compressed and written to the output file.  
+`)
+    .argument('<input>', "The input glTF, GLB or VRM file that should be compressed")
+    .option("--usecase <usecase>", `The usecase for the compression. This will set the compression settings. Options are ${UsecaseOptions.join(", ")}`, { validator: program.STRING })
+    .option("--config <config>", "The path to a JSON file containing the compression settings. This can also be a needle.config.json file with a \"compression\" object or usecase string.", { validator: program.STRING })
+    .option("--output <output>", "The output file. If not provided, the input file will be overwritten.", { validator: program.STRING })
+    .action(async ({ logger, args, options }) => {
+    logger.info("Transforming glTF file: " + args.input);
+    const stats = {
+        startTime: Date.now(),
+        totalGPUMemoryInMB: 0,
+        totalFilesProcessed: 0,
+        totalFileSizeInMB: 0,
+        totalFileSizeInMBBefore: 0,
+    };
+    let config = getConfig(options.config?.toString());
+    if (options.usecase) {
+        logger.info("Using usecase: " + options.usecase);
+        config = { ...config, ...createConfig(options.usecase.toString()) };
+    }
+    const file = args.input.toString();
+    const set = new Set();
+    await packGLTF(file, options.output?.toString() || file, {
+        config,
+        packedFiles: set,
+        stats,
+        debug: false,
+        useCache: true,
+    });
+    printStats(stats);
+})
+    .command("transform", "Transform a glTF file")
+    .help(`
+This will produce multiple versions of the input file, each with a different level of optimization.   
+Each version will be compressed and written to the output directory.
+`)
+    .argument('<input>', "The input glTF, GLB or VRM file that should be compressed")
+    .option("--usecase <usecase>", `The usecase for the compression. This will set the compression settings. Options are ${UsecaseOptions.join(", ")}`, { validator: program.STRING })
+    .option("--config <config>", "The path to a JSON file containing the compression settings. This can also be a needle.config.json file with a \"compression\" object or usecase string.", { validator: program.STRING })
+    // .option("--output <output>", "The output file. If not provided, the input file will be overwritten.", { validator: program.STRING })
+    .action(async ({ logger, args, options }) => {
+    logger.info("Transforming glTF file: " + args.input);
+    const stats = {
+        startTime: Date.now(),
+        totalGPUMemoryInMB: 0,
+        totalFilesProcessed: 0,
+        totalFileSizeInMB: 0,
+        totalFileSizeInMBBefore: 0,
+    };
+    let config = getConfig(options.config?.toString());
+    if (options.usecase) {
+        logger.info("Using usecase: " + options.usecase);
+        config = { ...config, ...createConfig(options.usecase.toString()) };
+    }
+    const file = args.input.toString();
+    const progressive_results = new Array();
+    await make_progressive({
+        path: file,
+        results: progressive_results,
+        config,
+        debug: false,
+        useCache: true,
+    });
+    console.log("Progressive results: ", progressive_results);
+    const opts = {
+        config,
+        stats,
+        debug: false,
+        useCache: true,
+    };
+    for (const prog of progressive_results) {
+        await packGLTF(prog, prog, opts);
+    }
+    await packGLTF(file, file, opts);
+    printStats(stats);
+});
+program.run();

package/dist/config/index.d.ts

@@ -0,0 +1,43 @@
+declare type Usecase = "unknown" | "product" | "game" | "metaverse";
+export declare const UsecaseOptions: string[];
+/**
+ * The config object contains information about how a file should be processed.
+ */
+export type Config = {
+    /** High-level configuration */
+    usecase: Usecase;
+};
+/**
+ * Create a config object with the given usecase.
+ */
+export declare function createConfig(usecase: string): {
+    usecase: Usecase;
+};
+/**
+ * Get the config object either provided by a CLI path or a needle.config.json file in the parent directory.
+ *
+ * @example CLI argument where the path points to a json file containing the config as `Config`
+ * ```sh
+ * node script.js --config path/to/my-optimization-config.json
+ * ```
+ *
+ * @example needle.config.json - the usecase can be provided as a string
+ * ```json
+ * {
+ *    "optimization": "product"
+ * }
+ * ```
+ *
+ * @example needle.config.json - the whole config object can be provided
+ * ```json
+ * {
+ *   "optimization": {
+ *      "usecase": "product"
+ *   }
+ * }
+ * ```
+ *
+ *
+ */
+export declare function getConfig(path?: string): Config;
+export {};

package/dist/config/index.js

@@ -0,0 +1,125 @@
+import { existsSync, readFileSync } from "fs";
+export const UsecaseOptions = ["product", "game", "metaverse"];
+const defaultConfig = {
+    usecase: "unknown",
+};
+/**
+ * Create a config object with the given usecase.
+ */
+export function createConfig(usecase) {
+    if (!UsecaseOptions.includes(usecase)) {
+        throw new Error(`Invalid usecase: \"${usecase}\". Valid usecases: ${UsecaseOptions.join(", ")}`);
+    }
+    return {
+        usecase: usecase
+    };
+}
+/**
+ * Get the config object either provided by a CLI path or a needle.config.json file in the parent directory.
+ *
+ * @example CLI argument where the path points to a json file containing the config as `Config`
+ * ```sh
+ * node script.js --config path/to/my-optimization-config.json
+ * ```
+ *
+ * @example needle.config.json - the usecase can be provided as a string
+ * ```json
+ * {
+ *    "optimization": "product"
+ * }
+ * ```
+ *
+ * @example needle.config.json - the whole config object can be provided
+ * ```json
+ * {
+ *   "optimization": {
+ *      "usecase": "product"
+ *   }
+ * }
+ * ```
+ *
+ *
+ */
+export function getConfig(path) {
+    if (path != null) {
+        if (!existsSync(path)) {
+            throw new Error(`No config found at \"${path}\"`);
+        }
+        return resolveConfig(path, readFileSync(path, "utf8"));
+    }
+    if (_cachedConfig !== undefined) {
+        return _cachedConfig;
+    }
+    // Resolve the config once and cache it
+    const result = internalResolveConfig();
+    if (result) {
+        console.log("INFO: Using optimization config with usecase: " + result.usecase);
+        _cachedConfig = result;
+    }
+    else {
+        console.log("INFO: No optimization config found. Using default config.");
+        _cachedConfig = defaultConfig;
+    }
+    return _cachedConfig;
+}
+let _cachedConfig = undefined;
+function internalResolveConfig() {
+    // Check if a config path is passed as an argument
+    const args = process.argv.slice(2);
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === "--config") {
+            if (i + 1 < args.length) {
+                const configPath = args[i + 1];
+                if (existsSync(configPath)) {
+                    const content = readFileSync(configPath, "utf8");
+                    return resolveConfig(configPath, content);
+                }
+                throw new Error(`Config file not found at path configured by CLI --config argument: \"${configPath}\"`);
+            }
+        }
+    }
+    // Check if a needle.config.json exists in the directory from which the script is run (or any parent directory)
+    const workingDir = process.cwd();
+    let directory = workingDir.replaceAll("\\", "/");
+    while (directory.length > 0) {
+        const configPath = `${directory}/needle.config.json`;
+        if (existsSync(configPath)) {
+            const content = readFileSync(configPath, "utf8");
+            const config = resolveConfig(configPath, content);
+            if (config) {
+                return config;
+            }
+        }
+        const lastSlash = directory.lastIndexOf("/");
+        if (lastSlash < 0) {
+            break;
+        }
+        directory = directory.slice(0, lastSlash);
+    }
+    return null;
+}
+function resolveConfig(filename, content) {
+    // Handle config being part of `needle.config.json`
+    if (filename.endsWith("needle.config.json")) {
+        const config = JSON.parse(content);
+        if (config.optimization) {
+            console.log("INFO: Found optimization config at \"" + filename + "\".");
+            // If the optimization config is a string, it's the usecase
+            if (typeof config.optimization === "string") {
+                return createConfig(config.optimization);
+            }
+            return config.optimization;
+        }
+        else {
+            console.log("INFO: No optimization config found in needle.config.json. Using default config.");
+            return null;
+        }
+    }
+    // Handle config being the content of the file
+    else if (content.trimStart().startsWith("{")) {
+        return JSON.parse(content);
+    }
+    else {
+        throw new Error("Invalid config file format. Expected JSON object.");
+    }
+}

package/dist/extensions/NEEDLE_opaque/NEEDLE_opaque.js

@@ -19,14 +19,14 @@ export function createOpaqueExtension(name, types, opts) {
         // private roots: Array<OpaqueProperty> = [];
         jsonPointerHandler;
         read(context) {
-            if (opts.breakpoint === true)
+            if (opts?.breakpoint === true)
                 debugger;
             currentGenerator = context.jsonDoc.json.asset?.generator;
             if (debugLog)
                 console.log("READ " + EXTENSION_NAME);
             this.jsonPointerHandler = new JsonPointerHandler(this.document, EXTENSION_NAME);
             this.jsonPointerHandler.debug = debugLog;
-            this.jsonPointerHandler.breakPoint = opts.breakpoint;
+            this.jsonPointerHandler.breakPoint = opts?.breakpoint;
             for (const type of types) {
                 switch (type) {
                     case PropertyType.ACCESSOR:
@@ -225,7 +225,7 @@ export function createOpaqueExtension(name, types, opts) {
             }
         }
         write(context) {
-            if (opts.breakpoint === true)
+            if (opts?.breakpoint === true)
                 debugger;
             if (opts?.write === false) {
                 return this;

package/dist/extensions/NEEDLE_opaque/index.d.ts

@@ -1,3 +1,3 @@
-import { IOpaqueExtension } from "./NEEDLE_opaque.js";
+import { Extension } from "@gltf-transform/core";
 export * from "./NEEDLE_opaque.js";
-export declare const ALL_EXTENSIONS: IOpaqueExtension[];
+export declare const ALL_EXTENSIONS: (typeof Extension)[];

package/dist/extensions/NEEDLE_progressive_mesh_settings/index.d.ts

@@ -1,7 +1,10 @@
 import { Extension, ExtensionProperty, PropertyType, ReaderContext, WriterContext } from "@gltf-transform/core";
 export declare interface IProgressiveMeshSettings {
-    guid: string;
+    /**
+     * When false no LODs will be generated for this mesh
+     */
     generateLods: boolean;
+    guid: string;
 }
 export declare class NEEDLE_progressive_mesh_settings extends Extension {
     static EXTENSION_NAME: string;

package/dist/extensions/NEEDLE_progressive_texture_settings/index.d.ts

@@ -1,5 +1,9 @@
 import { Extension, ExtensionProperty, PropertyType, ReaderContext, WriterContext } from "@gltf-transform/core";
 export declare interface IProgressiveTextureSettings {
+    /**
+     * When false the texture no progressive texture will be generated
+     */
+    generateLods?: boolean;
     maxSize: number;
     guid: string;
 }

package/dist/index.d.ts

@@ -1,4 +1,7 @@
+export * from "./config/index.js";
+export * from "./cli/index.js";
 export * from "./utils/index.js";
 export * from "./transforms/index.js";
 export * from "./extensions/index.js";
 export * from "./cache/index.js";
+export * from "./scripts/index.js";

package/dist/index.js

@@ -1,4 +1,7 @@
+export * from "./config/index.js";
+export * from "./cli/index.js";
 export * from "./utils/index.js";
 export * from "./transforms/index.js";
 export * from "./extensions/index.js";
 export * from "./cache/index.js";
+export * from "./scripts/index.js";

package/dist/scripts/index.d.ts

@@ -0,0 +1 @@
+export * from "./pack-gltf.js";

package/dist/scripts/index.js

@@ -0,0 +1 @@
+export * from "./pack-gltf.js";

package/dist/scripts/pack-gltf.d.ts

@@ -0,0 +1,12 @@
+import { Stats } from "../utils/index.js";
+import { Config } from '../config/index.js';
+export type PackGLTFOptions = {
+    debug: boolean;
+    useCache: boolean;
+    packedFiles?: Set<string>;
+    stats?: Stats;
+    config?: Config;
+};
+/** Compress a glTF file
+ */
+export declare function packGLTF(inputFile: string, outputFile: string, options: PackGLTFOptions): Promise<boolean>;

package/dist/scripts/pack-gltf.js

@@ -0,0 +1,119 @@
+import path from 'path';
+import { NodeIO } from '@gltf-transform/core';
+import { ALL_EXTENSIONS } from '@gltf-transform/extensions';
+import draco3d from 'draco3dgltf';
+import { existsSync, readFileSync, statSync, writeFileSync } from 'fs';
+import { MeshoptDecoder, MeshoptEncoder } from 'meshoptimizer';
+import { resample } from '@gltf-transform/functions';
+import { ALL_EXTENSIONS as NEEDLE_EXTENSIONS, NEEDLE_compression_texture, NEEDLE_mesh_compression, } from '../extensions/index.js';
+import { isMeshLOD, needle_animation_transform, needle_asset, needle_mesh_transform, needle_texture_transform, } from '../transforms/index.js';
+import { writeNodeIO, getVersion } from "../utils/index.js";
+import { addToCache, getHash, tryGetFromCache, } from "../cache/index.js";
+import { getConfig } from '../config/index.js';
+console.log(`[Needle Build Pipeline] pack glTF — version ${getVersion()}`);
+/** Compress a glTF file
+ */
+export async function packGLTF(inputFile, outputFile, options) {
+    if (!existsSync(inputFile)) {
+        console.error("WARN: can not pack, file does not exist: " + inputFile);
+        return;
+    }
+    const { debug, stats, packedFiles, useCache } = options;
+    if (debug && inputFile.includes(".debug.")) {
+        return;
+    }
+    // check if it's in the cache. 
+    // We only need to check mesh LOD files because image LODs are cache via our toktx transform
+    // We can not cache the main glTF files because the hash always changes for them
+    let cacheKey = undefined;
+    if (useCache && isMeshLOD(inputFile)) {
+        const existing = readFileSync(inputFile);
+        const hash = getHash(existing);
+        cacheKey = "packed-" + hash;
+        const cached = tryGetFromCache(cacheKey);
+        if (cached) {
+            console.log(`→ Loaded compressed file from cache: \"${path.basename(inputFile)}\"`);
+            writeFileSync(inputFile, cached);
+            return;
+        }
+    }
+    if (packedFiles) {
+        if (packedFiles.has(inputFile))
+            return;
+        packedFiles.add(inputFile);
+    }
+    try {
+        const config = options.config || getConfig();
+        const prevSizeInMB = statSync(inputFile).size / 1024 / 1024;
+        console.log(`→ Compressing ${prevSizeInMB.toFixed(1)} MB: ${inputFile}`);
+        // const isProgressiveAsset = isLOD(file);
+        const startTime = Date.now();
+        const io = new NodeIO()
+            .registerExtensions(ALL_EXTENSIONS)
+            .registerExtensions(NEEDLE_EXTENSIONS)
+            .registerExtensions([
+            NEEDLE_compression_texture,
+            NEEDLE_mesh_compression,
+        ])
+            .registerDependencies({
+            'draco3d.decoder': await draco3d.createDecoderModule(),
+            'draco3d.encoder': await draco3d.createEncoderModule(),
+            'meshopt.decoder': MeshoptDecoder,
+            'meshopt.encoder': MeshoptEncoder,
+        });
+        const document = await io.read(inputFile);
+        /** @ts-ignore */
+        document.getLogger().verbosity = 0;
+        let totalGPUTextureMemmory = 0;
+        /** @type {Array<import('@gltf-transform/core').Transform>} */
+        const transforms = [
+            needle_asset(),
+            needle_texture_transform({
+                file: inputFile,
+                useCache,
+                noToktx: false,
+                debug: debug,
+                reportGPUMemory: val => {
+                    if (stats)
+                        stats.totalGPUMemoryInMB += val;
+                },
+                config,
+            }),
+            needle_mesh_transform({ file: inputFile, config }, { ratio: 0.75, error: 0.0005 }),
+            needle_animation_transform({}),
+            resample(),
+            // TODO: dedup removes skybox texture
+            // dedup(),
+        ];
+        // TODO: progressive assets need to make sure that e.g. textures are used
+        // if (!isProgressiveAsset) {
+        //     transforms.push(prune());
+        // }
+        await document.transform(...transforms);
+        if (!outputFile)
+            outputFile = inputFile;
+        if (debug)
+            outputFile += ".debug.glb";
+        await writeNodeIO(io, outputFile, document);
+        if (useCache && cacheKey != undefined && existsSync(outputFile))
+            addToCache(cacheKey, readFileSync(outputFile));
+        const duration = Date.now() - startTime;
+        const sizeInMB = statSync(outputFile).size / 1024 / 1024;
+        const filename = path.basename(outputFile);
+        const gpuMemoryInMB = totalGPUTextureMemmory / 1024 / 1024;
+        console.log(`← Compressing done in ${(duration / 1000).toFixed(1)} sec, ${prevSizeInMB.toFixed(1)} MB → ${sizeInMB.toFixed(1)} MB (GPU: ${gpuMemoryInMB.toFixed(1)} MB textures): ${filename} at ${outputFile}`);
+        if (stats) {
+            stats.totalFilesProcessed++;
+            stats.totalFileSizeInMB += sizeInMB;
+            stats.totalFileSizeInMBBefore += prevSizeInMB;
+            stats.totalGPUMemoryInMB += gpuMemoryInMB;
+        }
+        return true;
+    }
+    catch (err) {
+        console.error("ERR: packing " + inputFile + " failed: " + err.message);
+        if (debug)
+            throw err;
+        return false;
+    }
+}

package/dist/transforms/needle_common.d.ts

@@ -1,14 +1,16 @@
 import { Document, Texture } from '@gltf-transform/core';
 import { NEEDLE_compression_texture_schema } from '../extensions/index.js';
+import { Config } from '../config/index.js';
 export interface NeedleTransformContext {
     /** full path to the file being processed */
     file: string;
+    config: Config;
     debug?: boolean;
     useCache: boolean;
     noToktx: boolean;
 }
 export interface INeedleTextureTransformContext {
     prepare(document: Document): Promise<void | boolean>;
-    process(index: number, texture: Texture, settings: NEEDLE_compression_texture_schema): Promise<boolean>;
+    process(index: number, texture: Texture, settings: NEEDLE_compression_texture_schema, context: NeedleTransformContext): Promise<boolean>;
     finalize(document: Document): Promise<void>;
 }

package/dist/transforms/needle_mesh_transform.d.ts

@@ -1,8 +1,10 @@
 import { Transform, Document, Primitive, Mesh } from "@gltf-transform/core";
 import { SimplifyOptions, WeldOptions } from "@gltf-transform/functions";
+import { Config } from "../config/index.js";
 declare type MeshTransformContext = {
     file: string;
+    config: Config;
 };
-export declare const needle_mesh_transform: (context: MeshTransformContext, simplify: SimplifyOptions) => Transform;
+export declare const needle_mesh_transform: (context: MeshTransformContext, simplify: Omit<SimplifyOptions, "simplifier">) => Transform;
 export declare function compressPrimitive(document: Document, mesh: Mesh, prim: Primitive, index: number, weldOptions: Required<WeldOptions>, meshOptions: Required<SimplifyOptions>): Promise<Primitive>;
 export {};

package/dist/transforms/needle_progressive.d.ts

@@ -1,6 +1,9 @@
 import { ILogger, Texture, Transform, vec2 } from '@gltf-transform/core';
+import { Config } from '../config/index.js';
 declare interface ProgressiveOptions {
     path: string | Array<string>;
+    results: Array<string>;
+    config: Config;
     debug?: boolean;
     useCache?: boolean;
 }

package/dist/transforms/needle_progressive.js

@@ -3,7 +3,7 @@ import { SIMPLIFY_DEFAULTS, WELD_DEFAULTS, listTextureSlots, sparse } from '@glt
 import draco3d from 'draco3dgltf';
 import { NEEDLE_PROGRESSIVE_EXTENSION_NAME, NEEDLE_progressive } from "../extensions/NEEDLE_progressive/index.js";
 import { createOpaqueExtension, currentGenerator, NEEDLE_compression_texture, NEEDLE_mesh_compression, NEEDLE_progressive_mesh_settings, NEEDLE_progressive_texture_settings, registerExtensions as registerDefaultExtensions } from '../extensions/index.js';
-import path, { basename } from 'path';
+import path, { basename, resolve } from 'path';
 import { existsSync, readFileSync, rmSync, statSync, writeFileSync } from 'fs';
 import { addMetaToCache, addToCache, getHash, getKeyWithHash, tryGetFromCache, tryGetMetaFromCache } from '../cache/index.js';
 import sharp from "sharp";
@@ -94,6 +94,7 @@ async function onProcess(file, opts) {
                 filename = filename + ".debug." + extension;
             }
             await writeNodeIO(io, filename, document);
+            opts.results.push(filename);
             console.log("← Transforming done: " + filename);
         }
     }
@@ -143,7 +144,7 @@ export function make_progressive_textures(filePath, _options = TEXTURE_RESIZE_DE
             if (!settings) {
                 const size = texture.getSize();
                 if (size?.length >= 2 && size[0] <= 128 && size[1] <= 128) {
-                    logger.warn(`[${NAME}] Skipping texture[${textureIndex}], no settings found`);
+                    logger.warn(`[${NAME}] Skipping texture[${textureIndex}], no settings found and the texture is already < 128x128`);
                     continue;
                 }
                 else {
@@ -154,6 +155,10 @@ export function make_progressive_textures(filePath, _options = TEXTURE_RESIZE_DE
                     logger.debug(`[${NAME}] No settings found for texture[${index}] - will use default settings (maxSize: ${settings.maxSize}, guid: ${settings.guid})`);
                 }
             }
+            else if (settings.generateLods === false) {
+                logger.debug(`[${NAME}] Skipping texture[${textureIndex}]: progressive texture disabled`);
+                continue;
+            }
             if (settings.maxSize == undefined || settings.maxSize <= 0) {
                 logger.warn(`[${NAME}] Skipping texture[${textureIndex}], settings are invalid (maxSize: ${settings.maxSize})`);
                 continue;
@@ -175,6 +180,7 @@ export function make_progressive_textures(filePath, _options = TEXTURE_RESIZE_DE
             if (!outPath) {
                 continue;
             }
+            opts.results.push(outPath);
             const { key, hash } = getKeyWithHash(texture);
             const relName = path.relative(directory, outPath);
             // TODO: this path should be added to the NEEDLE dependencies extension
@@ -548,6 +554,7 @@ export function make_progressive_meshes(filePath, _options, opts) {
                 const model = progressiveExt.createMesh({
                     guid: settings.guid,
                     lods: generatedLODInfos.map(l => {
+                        opts.results.push(resolve(outputDirectory, l.path));
                         return {
                             path: l.path,
                             hash: l.content_hash.toString(),

package/dist/transforms/needle_texture_transform.d.ts

@@ -1,5 +1,13 @@
 import { Texture } from "@gltf-transform/core";
 import { Transform } from '@gltf-transform/core';
+import { NeedleWebPContext } from "./needle_webp.js";
 import { NeedleTransformContext } from "./needle_common.js";
+import { NeedleToktxContext } from "./needle_toktx.js";
 export declare function resizeTextureIfNecessary(texture: Texture): Promise<void>;
-export declare const needle_texture_transform: (options: NeedleTransformContext) => Transform;
+interface NeedleTextureTransformContext extends NeedleTransformContext {
+    webPContext: NeedleWebPContext;
+    toktxContext: NeedleToktxContext;
+    reportGPUMemory?: (bytes: number) => void;
+}
+export declare const needle_texture_transform: (options: NeedleTransformContext & Pick<NeedleTextureTransformContext, "reportGPUMemory">) => Transform;
+export {};