@needle-tools/gltf-build-pipeline 1.6.0-alpha.6 → 2.0.0-alpha

package/CHANGELOG.md

@@ -4,8 +4,18 @@ 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.6] - 2023-05-30
+## [2.0.0-alpha] - 2023-06-01
+- update gltf-transform dependency to 4.x
+- change: ensure ETC1S and UASTC textures are power of 2 
+
+- CLI: commands can be run with `needle-gltf <command>`
+- CLI: add `--cache` to allow disabling cache with `--cache False` (default true)
+- CLI: add `--stats` to produce `.needle.stats.json` (default false)
+- CLI: change `--output` to be the optional second argument
+
+## [1.6.0-alpha.7] - 2023-05-30
 - fix: npx cli command return wrong error due to `packGLTF` not returning a booelan
+- fix: mjs script import paths
 
 ## [1.6.0-alpha.5] - 2023-05-28
 - fix: determine build pipeline version

package/README.md

@@ -8,6 +8,24 @@ Includes support for generating LOD quality level for textures and meshes that c
 - [Example on Github](https://github.com/needle-engine/progressive-meshes-sample)
 
 
+## Usage
+
+In general all files that have been processed by this package are valid glTF/GLB files.    
+The glTF Build Pipeline package is meant to be used as a last step before delivery.   
+That means:
+- files are meant to be loaded e.g. in a web runtime like three.js 
+- files are not to be opened in Blender again to be further edited    
+
+To load progressively enhanced glTF files in any three.js based engine see examples at [@needle-tools/gltf-progressive](https://www.npmjs.com/package/@needle-tools/gltf-progressive)
+
+### Installation
+
+`npx @needle-tools/gltf-build-pipeline@latest`
+
+### Commands
+- `gltf-build-pipeline help` - use help to see options for each command
+- `gltf-build-pipeline compress <input>`
+- `gltf-build-pipeline transform <input>`
 
 # Contact ✒️
 <b>[🌵 needle — tools for creators](https://needle.tools)</b> • 

package/dist/package.json

@@ -1,30 +1,51 @@
 {
     "name": "@needle-tools/gltf-build-pipeline",
-    "version": "1.6.0-alpha.6",
+    "version": "2.0.0-alpha",
     "description": "Pipeline and tools for optimizing gltf files using gltf-transform and compression settings within glTF extensions",
     "main": "index.mjs",
     "type": "module",
     "readme": "README.md",
+    "author": {
+        "name": "Needle",
+        "email": "help@needle.tools",
+        "url": "https://needle.tools/"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/needle-tools/needle-gltf-extensions.git"
+    },
     "bin": {
-        "gltf-build-pipeline": "./dist/src/cli/index.js"
+        "gltf-build-pipeline": "./dist/src/cli/index.js",
+        "needle-gltf": "./dist/src/cli/index.js"
     },
     "scripts": {
         "start": "node scripts/index.mjs",
         "dev": "npm-watch compile",
+        "compile": "tsc || exit 1",
+        "clear-caches": "node scripts/clear-caches.mjs",
+        "limit-caches": "node scripts/limit-caches.mjs",
         "transform": "node scripts/index.mjs",
         "transform:make-progressive": "node scripts/make-progressive.mjs",
         "transform:pack-gltf": "node --no-experimental-fetch scripts/pack-gltf.mjs",
         "pack-gltf": "node --no-experimental-fetch scripts/pack-gltf.mjs",
-        "dev:pack-gltf": "npm run compile && node scripts/pack-gltf.mjs",
-        "clear-caches": "node scripts/clear-caches.mjs",
-        "limit-caches": "node scripts/limit-caches.mjs",
-        "compile": "tsc || exit 1"
+        "dev:pack-gltf": "npm run compile && node scripts/pack-gltf.mjs"
+    },
+    "devDependencies": {
+        "@img/sharp-win32-x64": "^0.33.4",
+        "@types/node": "^18.7.23",
+        "npm-watch": "^0.13.0",
+        "typescript": "^4.9.5"
+    },
+    "optionalDependencies": {
+        "@img/sharp-linux-arm": "^0.33.4",
+        "@img/sharp-win32-x64": "^0.33.4"
     },
     "dependencies": {
         "@donmccurdy/caporal": "~0.0.10",
-        "@gltf-transform/core": "^3.10.1",
-        "@gltf-transform/extensions": "^3.10.1",
-        "@gltf-transform/functions": "^3.10.1",
+        "@gltf-transform/cli": "^4.0.1",
+        "@gltf-transform/core": "^4.0.1",
+        "@gltf-transform/extensions": "^4.0.1",
+        "@gltf-transform/functions": "^4.0.1",
         "command-exists": "^1.2.9",
         "command-line-args": "^5.2.1",
         "draco3dgltf": "^1.5.3",
@@ -36,7 +57,7 @@
         "ndarray-pixels": "^2.0.1",
         "p-limit": "3.1.0",
         "semver": "^7.3.7",
-        "sharp": "^0.32.6",
+        "sharp": "^0.33.4",
         "tmp": "^0.2.1",
         "uuid": "^9.0.1"
     },
@@ -48,20 +69,5 @@
             "extensions": "ts",
             "quiet": false
         }
-    },
-    "devDependencies": {
-        "@types/node": "^18.7.23",
-        "nodemon": "^3.1.2",
-        "npm-watch": "^0.13.0",
-        "typescript": "^4.9.5"
-    },
-    "author": {
-        "name": "Needle",
-        "email": "help@needle.tools",
-        "url": "https://needle.tools/"
-    },
-    "repository": {
-        "type": "git",
-        "url": "git+https://github.com/needle-tools/needle-gltf-extensions.git"
     }
 }

package/dist/src/cli/index.js

@@ -7,8 +7,8 @@ import { UsecaseOptions, createConfig, getConfig } from '../config/index.js';
 import { make_progressive } from '../transforms/needle_progressive.js';
 import { cacheSizeLimit, clearCache } from '../cache/cache.js';
 import { existsSync, statSync } from 'fs';
-import { foreachGLTF } from '../utils/fileutils.js';
-import { dirname } from 'path';
+import { foreachGLTF, getDirName } from '../utils/fileutils.js';
+import path, { dirname } from 'path';
 import { ERROR_CODES } from '../constants.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`
@@ -30,10 +30,12 @@ Caches are limited to ${cacheSizeLimit} MB disc space by default.
 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 OR a directory that contains files to be compressed")
-    .option("--usecase <usecase>", `The usecase for the compression. This will set the compression settings. Possible options: [${UsecaseOptions.join(", ")}] e.g. \`--usecase ${UsecaseOptions[0]}\"`, { validator: program.STRING })
+    .argument('<output>', "The output file. If not provided, the input file will be overwritten.", { default: "" })
+    .option("--usecase <usecase>", `The usecase for the compression allows you to determine how your asset is supposed to be used:\nThis will set compression and transform settings on a high level if no other settings are found.\nPossible options: [${UsecaseOptions.join(", ")}] e.g. \"--usecase ${UsecaseOptions[0]}\"`, { 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 })
-    .option("--output-stats", "The path to a JSON file where the stats will be written to.", { validator: program.STRING })
+    .option("--stats", "Output a stats file next to input file (or inside the input directory). It will be named as the input file/directory \"<input>.needle.stats.json\"", { validator: program.BOOLEAN, default: false })
+    .option("--cache", "Use \"--cache False\" to disable caching.\nWhen caching is enabled then previously processed files will be detected and loaded from disc cache instead of being processed again if settings or the file contents have not changed.", { validator: program.BOOLEAN, default: true })
+    .option("--debug", "Enable for more verbose outout with \"--debug True\"", { validator: program.BOOLEAN, default: false })
     .action(async ({ logger, args, options }) => {
     logger.info("Transforming glTF file: " + args.input);
     const stats = {
@@ -54,8 +56,10 @@ Compress a single glTF file. The input file is compressed and written to the out
             config.usecase = options.usecase.toString();
         }
     }
+    const debug = options.debug === true;
     const file = args.input.toString();
-    const outDir = statSync(file).isDirectory() ? file : dirname(file);
+    const isDirectory = statSync(file).isDirectory();
+    const outDir = isDirectory ? file : dirname(file);
     let outputIsDirectory = false;
     if (statSync(file).isDirectory() && options.output) {
         if (statSync(options.output.toString()).isDirectory()) {
@@ -73,17 +77,20 @@ Compress a single glTF file. The input file is compressed and written to the out
     const file_stats = [];
     const set = new Set();
     await foreachGLTF(file, async (file) => {
-        let outputFile = options.output?.toString() || file;
+        let outputFile = args.output?.toString();
+        if (!outputFile?.length) {
+            outputFile = file;
+        }
         if (outputIsDirectory) {
             const filename = file.replaceAll("\\", "/").split("/").pop();
-            outputFile = options.output?.toString() + "/" + filename;
+            outputFile = args.output?.toString() + "/" + filename;
         }
         const res = await packGLTF(file, outputFile, {
             config,
             packedFiles: set,
             stats,
-            debug: false,
-            useCache: true,
+            debug,
+            useCache: options.cache !== false,
             logger: logger,
             file_stats: file_stats,
         });
@@ -93,8 +100,9 @@ Compress a single glTF file. The input file is compressed and written to the out
     });
     printStats(stats);
     console.log("Stats: ", options);
-    if (options.outputStats) {
-        writeFileStatsToFile(file_stats, options.outputStats.toString());
+    if (options.stats) {
+        const statsFile = (isDirectory ? (path.join(file, getDirName(file))) : file) + ".needle.stats.json";
+        writeFileStatsToFile(file_stats, statsFile);
     }
 })
     .command("transform", "Transform (progressive loading) and compress glTF, GLB or VRM files")
@@ -103,10 +111,12 @@ This will produce multiple versions of the input file, each with a different lev
 Each version will be compressed and written to the output directory.
 `)
     .argument('<input>', "The input glTF, GLB or VRM file that should be compressed OR a directory that contains files to be compressed")
+    // .argument('<output>', "The output file. If not provided, the input file will be overwritten.", { default: "" })
     .option("--usecase <usecase>", `The usecase for the compression. This will set the compression settings. Possible options: [${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 directory. If not provided, the input files will be overwritten.", { validator: program.STRING })
-    .option("--output-stats", "The path to a JSON file where the stats will be written to.", { validator: program.STRING })
+    .option("--stats", "Output a stats file next to input file (or inside the input directory). It will be named as the input file/directory \"<input>.needle.stats.json\"", { validator: program.BOOLEAN, default: false })
+    .option("--cache", "Use \"--cache False\" to disable caching.\nWhen caching is enabled then previously processed files will be detected and loaded from disc cache instead of being processed again if settings or the file contents have not changed.", { validator: program.BOOLEAN, default: true })
+    .option("--debug", "Enable for more verbose outout with \"--debug True\"", { validator: program.BOOLEAN, default: false })
     .action(async ({ logger, args, options }) => {
     logger.info("Transforming glTF file: " + args.input);
     const stats = {
@@ -127,19 +137,22 @@ Each version will be compressed and written to the output directory.
             config.usecase = options.usecase.toString();
         }
     }
-    const file = args.input.toString();
-    const outDir = statSync(file).isDirectory() ? file : dirname(file);
+    let file = args.input.toString();
+    const isDirectory = statSync(file).isDirectory();
+    const outDir = isDirectory ? file : dirname(file);
     const file_stats = [];
     const set = new Set();
+    const useCache = options.cache !== false;
+    const debug = options.debug === true;
     await foreachGLTF(file, async (file) => {
-        logger.info("> Transform " + file);
+        logger.info("→ Transform " + file);
         const progressive_results = new Array();
         await make_progressive({
             path: file,
             results: progressive_results,
             config,
-            debug: false,
-            useCache: true,
+            debug,
+            useCache,
         }).catch(err => {
             logger.error(err);
             process.exit(ERROR_CODES.PROGRESSIVE_FAILED);
@@ -148,25 +161,24 @@ Each version will be compressed and written to the output directory.
             config,
             stats,
             packedFiles: set,
-            debug: false,
-            useCache: true,
+            debug,
+            useCache,
             logger: logger,
             file_stats,
         };
         for (const res of progressive_results) {
-            logger.info("> Compress " + res);
             if (await packGLTF(res, res, opts) === false) {
                 process.exit(ERROR_CODES.PACKING_FAILED);
             }
         }
-        logger.info("> Compress " + file);
         if (await packGLTF(file, file, opts) === false) {
             process.exit(ERROR_CODES.PACKING_FAILED);
         }
     });
     printStats(stats);
-    if (options.outputStats) {
-        writeFileStatsToFile(file_stats, options.outputStats.toString());
+    if (options.stats) {
+        const statsFile = (isDirectory ? (path.join(file, getDirName(file))) : file) + ".needle.stats.json";
+        writeFileStatsToFile(file_stats, statsFile);
     }
 });
 program.run();

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

@@ -15,7 +15,7 @@ export interface IOpaqueProperty {
     /** register a reference so gltf-transform will not remove it in e.g. dedup
      * https://github.com/donmccurdy/glTF-Transform/issues/980#issuecomment-1585748202
      */
-    setReference(name: string, value: any): any;
+    setReference(name: string, value: any, attributes?: Record<string, any>): void;
 }
 export interface IExtensionWriter {
     /** used by progressive texture extension to pass an extension between documents */

package/dist/src/extensions/NEEDLE_opaque/NEEDLE_opaque.js

@@ -1,4 +1,4 @@
-import { Extension, ExtensionProperty, PropertyType } from '@gltf-transform/core';
+import { Extension, ExtensionProperty, PropertyType, TextureChannel } from '@gltf-transform/core';
 import { getTexture, tryGetInArray, writeExtension } from '../utils.js';
 const ALL_PROPERTY_TYPES = [];
 for (const key in PropertyType) {
@@ -16,6 +16,7 @@ export function createOpaqueExtension(name, types, opts) {
     class NEEDLE_opaque extends Extension {
         extensionName = EXTENSION_NAME;
         static EXTENSION_NAME = EXTENSION_NAME;
+        prewriteTypes = [PropertyType.MATERIAL];
         // private roots: Array<OpaqueProperty> = [];
         jsonPointerHandler;
         read(context) {
@@ -118,8 +119,8 @@ export function createOpaqueExtension(name, types, opts) {
                                 console.log("WARN: could potentially not find gltf transform texture for " + index);
                                 texture = context.textures[index];
                             }
-                            this.jsonPointerHandler.read(context, texture, ext);
                             const prop = this.createExtension();
+                            this.jsonPointerHandler.read(context, texture, ext, prop);
                             texture.setExtension(EXTENSION_NAME, prop);
                             const handler = new TextureHandler(this.document, textureDefinition, EXTENSION_NAME, ext, debugLog);
                             prop.add(handler);
@@ -142,8 +143,8 @@ export function createOpaqueExtension(name, types, opts) {
                                 if (!ext)
                                     return;
                                 const primitive = primitives[primitiveIndex];
-                                this.jsonPointerHandler.read(context, primitive, ext);
                                 const prop = this.createExtension();
+                                this.jsonPointerHandler.read(context, primitive, ext, prop);
                                 primitive.setExtension(EXTENSION_NAME, prop);
                                 // this is invoked on write
                                 prop.add(ctx => {
@@ -164,8 +165,8 @@ export function createOpaqueExtension(name, types, opts) {
                         if (ext) {
                             this.lightmapWorkaround(context);
                             const root = this.document.getRoot();
-                            this.jsonPointerHandler.read(context, root, ext);
                             const prop = this.createExtension();
+                            this.jsonPointerHandler.read(context, root, ext, prop);
                             root.setExtension(EXTENSION_NAME, prop);
                             prop.add(ctx => {
                                 ctx.jsonDoc.json.extensions = ctx.jsonDoc.json.extensions || {};
@@ -224,6 +225,13 @@ export function createOpaqueExtension(name, types, opts) {
                 console.error("ERR: " + error);
             }
         }
+        prewrite(context, _propertyType) {
+            // Attempt resolve textures here so that the json.textures is already populated for cases where a texture isn't used by any material 
+            // this is e.g. the case for textures that are just referenced by a component but not used by any texture
+            // https://linear.app/needle/issue/NE-4928
+            this.jsonPointerHandler.resolveAndWrite(context, "prewrite");
+            return this;
+        }
         write(context) {
             if (opts?.breakpoint === true)
                 debugger;
@@ -232,7 +240,7 @@ export function createOpaqueExtension(name, types, opts) {
             }
             if (debugLog)
                 console.log("WRITE " + EXTENSION_NAME);
-            this.jsonPointerHandler.resolveAndWrite(context);
+            this.jsonPointerHandler.resolveAndWrite(context, "write");
             const root = this.document.getRoot();
             // for (const rootExt of this.roots) {
             //     rootExt.onWrite(context, root);
@@ -313,11 +321,11 @@ export function createOpaqueExtension(name, types, opts) {
         extensionName = typeof EXTENSION_NAME;
         parentTypes = ExtensionPropertyTypes;
         propertyType = "NEEDLE_opaque_property";
-        setReference(name, value) {
-            this.setRef(name, value, { modifyChild: true });
-        }
         init() {
         }
+        setReference(name, value, attributes = { modifyChild: true }) {
+            this.setRef(name, value, attributes);
+        }
         writers = [];
         add(writer) {
             if (typeof writer === "function") {
@@ -520,7 +528,7 @@ class JsonPointerHandler {
         this.document = document;
         this.id = id;
     }
-    read(context, prop, obj, ext, key, fullPath) {
+    read(context, extProp, obj, prop, key, fullPath) {
         const value = key !== undefined ? obj[key] : obj;
         // the pointer path contains the full path from the root object to the json pointer
         if (key !== undefined) {
@@ -535,7 +543,7 @@ class JsonPointerHandler {
             case 'object':
                 if (value !== null && value !== undefined) {
                     for (const key of Object.keys(value)) {
-                        this.read(context, prop, value, ext, key, fullPath);
+                        this.read(context, extProp, value, prop, key, fullPath);
                     }
                 }
                 break;
@@ -568,6 +576,15 @@ class JsonPointerHandler {
                                 pointer = new JsonPointer(path, res, value);
                                 pointer.debug = this.debug;
                                 this.map.set(value, pointer);
+                                // Assume all texture slots are being used. The referenceName is the json pointer right now - usually this is e.g. `baseColorTexture` (the name ends up in the slots array)
+                                const referenceName = value;
+                                // const slots = listTextureSlots(object);
+                                prop.setReference(referenceName, object, { channels: TextureChannel.R | TextureChannel.G | TextureChannel.B | TextureChannel.A });
+                                // make sure there's a reference to the buffer to avoid dedup or the buffer being removed because it MIGHT not be used by any node
+                                // TODO: how do we get the buffer that the texture/image is currently using - here we just take the first buffer but this might not be correct
+                                const buffer = this.document.getRoot().listBuffers()[0];
+                                if (buffer)
+                                    prop.setReference("buffer", buffer);
                             }
                             else {
                                 console.warn("Texture not found", fullPath, value);
@@ -585,23 +602,24 @@ class JsonPointerHandler {
                         if (this.debug)
                             console.log("Read pointer", value);
                         const index = parseInt(value.substring("/materials/".length));
-                        const mat = context.materials[index];
-                        if (mat) {
+                        const object = context.materials[index];
+                        if (object) {
                             // set a reference to the material to avoid dedup or the material being removed because it MIGHT not be used by any node
                             // BUT a component is referencing the material so we don't want it ever to be removed 
                             // see https://github.com/donmccurdy/glTF-Transform/issues/980#issuecomment-1585748202
-                            if (ext) {
-                                ext.setReference(value, mat);
+                            if (prop) {
+                                prop.setReference(value, object);
                             }
                             let pointer = this.map.get(value);
                             if (!pointer) {
                                 const definition = context.jsonDoc.json.materials[index];
-                                const res = new MaterialIndexResolver(this.document, mat, definition);
+                                const res = new MaterialIndexResolver(this.document, object, definition);
                                 res.debug = this.debug;
                                 res.init(context); // < init here otherwise the fields defined in the TexturePointer will be undefined (this caused e.g. finding the previous texture filter to fail)
                                 pointer = new JsonPointer("/materials/", res, value);
                                 pointer.debug = this.debug;
                                 this.map.set(value, pointer);
+                                prop.setReference(value, object);
                             }
                             pointer?.register(obj, key, fullPath);
                         }
@@ -625,6 +643,7 @@ class JsonPointerHandler {
                         pointer.debug = this.debug;
                         pointer.register(obj, key, fullPath);
                         this.map.set(dictKey, pointer);
+                        prop.setReference(dictKey, object);
                     }
                 }
                 else if (
@@ -663,9 +682,7 @@ class JsonPointerHandler {
                         pointer.debug = this.debug;
                         pointer.register(obj, key, fullPath);
                         this.map.set(dictKey, pointer);
-                        if (ext) {
-                            ext.setReference(dictKey, object);
-                        }
+                        prop.setReference(dictKey, object);
                     }
                 }
                 break;
@@ -673,10 +690,10 @@ class JsonPointerHandler {
                 break;
         }
     }
-    resolveAndWrite(context) {
+    resolveAndWrite(context, step) {
         this.map?.forEach(ptr => {
-            ptr.resolve(context);
-            ptr.write();
+            if (ptr.resolve(context, step))
+                ptr.write();
         });
     }
 }
@@ -698,8 +715,12 @@ class JsonPointer {
         this._props.push(prop);
         this._debugInfo.push(fullpath);
     }
-    newPointer;
-    resolve(context) {
+    newPointer = undefined;
+    resolve(context, step) {
+        // If the pointer was already resolved, we don't need to do it again
+        if (this.newPointer !== undefined) {
+            return true;
+        }
         //@ts-ignore
         this.resolver.debug = this.debug;
         const index = this.resolver.resolve(context);
@@ -712,12 +733,20 @@ class JsonPointer {
             }
             if (this.debug)
                 console.log(`RESOLVED pointer ${this.oldPointer} to → ${this.newPointer}`);
+            return true;
         }
         else {
-            console.log("ERR: 🧨 FAILED to resolve pointer", this.pointerBase, ` used by ${this._debugInfo.join(", ")}`);
+            // If the pointer could not be resolved during write we need to log an error
+            if (step === "write")
+                console.log("ERR: 🧨 FAILED to resolve pointer", this.pointerBase, ` used by ${this._debugInfo.join(", ")}`);
         }
+        return false;
     }
+    _didWrite = false;
     write() {
+        if (this._didWrite)
+            return;
+        this._didWrite = false;
         for (let i = 0; i < this._objects.length; i++) {
             const obj = this._objects[i];
             const prop = this._props[i];

package/dist/src/scripts/pack-gltf.js

@@ -4,9 +4,9 @@ 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 { dedup, prune, 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 { isLOD, isMeshLOD, needle_animation_transform, needle_asset, needle_mesh_transform, needle_texture_transform, } from '../transforms/index.js';
 import { createNewFilestats, writeNodeIO } from "../utils/index.js";
 import { addToCache, getHash, tryGetFromCache, } from "../cache/index.js";
 import { getConfig } from '../config/index.js';
@@ -19,10 +19,7 @@ export async function packGLTF(inputFile, outputFile, options) {
     const { debug, stats, packedFiles, useCache, logger } = options;
     if (!existsSync(inputFile)) {
         logger.error("WARN: can not pack, file does not exist: " + inputFile);
-        return;
-    }
-    if (debug && inputFile.includes(".debug.")) {
-        return true;
+        return false;
     }
     // check if it's in the cache. 
     // We only need to check mesh LOD files because image LODs are cache via our toktx transform
@@ -48,7 +45,6 @@ export async function packGLTF(inputFile, outputFile, options) {
         const config = options.config || getConfig();
         const prevSizeInMB = statSync(inputFile).size / 1024 / 1024;
         logger.info(`→ Compressing ${prevSizeInMB.toFixed(1)} MB: ${inputFile}`);
-        // const isProgressiveAsset = isLOD(file);
         const startTime = Date.now();
         const io = new NodeIO()
             .registerExtensions(ALL_EXTENSIONS)
@@ -65,7 +61,7 @@ export async function packGLTF(inputFile, outputFile, options) {
         });
         const document = await io.read(inputFile);
         /** @ts-ignore */
-        document.getLogger().verbosity = Verbosity.ERROR;
+        document.getLogger().verbosity = options.debug ? Verbosity.DEBUG : Verbosity.WARN;
         let totalGPUTextureMemory = 0;
         /** @type {Array<import('@gltf-transform/core').Transform>} */
         const transforms = [
@@ -83,18 +79,17 @@ export async function packGLTF(inputFile, outputFile, options) {
             needle_mesh_transform({ file: inputFile, config }, { ratio: 0.75, error: 0.0005 }),
             needle_animation_transform({}),
             resample(),
-            // TODO: dedup removes skybox texture
-            // dedup(),
+            dedup(),
+            // prune(),
         ];
-        // TODO: progressive assets need to make sure that e.g. textures are used
-        // if (!isProgressiveAsset) {
-        //     transforms.push(prune());
-        // }
+        const isProgressiveAsset = isLOD(inputFile);
+        // TODO: progressive mesh LODs should not be pruned right now because it will remove e.g. UVs from meshes (and probably blend shapes too) (so we just not do it for any progressive asset) 
+        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));
@@ -116,7 +111,7 @@ export async function packGLTF(inputFile, outputFile, options) {
         return true;
     }
     catch (err) {
-        logger.error("ERR: packing " + inputFile + " failed: " + err.message);
+        logger.error(`packing ${path.basename(inputFile)} failed: ${err}`);
         if (debug)
             throw err;
         return false;

package/dist/src/transforms/needle_mesh_transform.js

@@ -52,7 +52,6 @@ async function simplifierTransform(document, _context, _options) {
         options.simplifier = simplifier;
     const weldOptions = {
         ...WELD_DEFAULTS,
-        tolerance: 0.00000000001,
         overwrite: true,
     };
     for (const mesh of document.getRoot().listMeshes()) {
@@ -99,8 +98,8 @@ async function simplifierTransform(document, _context, _options) {
 }
 export async function compressPrimitive(document, mesh, prim, index, weldOptions, meshOptions) {
     const logger = document.getLogger();
-    logger.debug(`weld: primitive[${index}] of mesh "${mesh.getName()}" → tolerance: ${weldOptions.tolerance}`);
-    weldPrimitive(document, prim, weldOptions);
+    logger.debug(`weld: primitive[${index}] of mesh "${mesh.getName()}"`);
+    weldPrimitive(prim, weldOptions);
     // make sure we wait for the mesh simplifier to be ready
     if (meshOptions.simplifier && meshOptions.simplifier?.ready instanceof Promise) {
         const res = await meshOptions.simplifier?.ready
@@ -116,7 +115,7 @@ export async function compressPrimitive(document, mesh, prim, index, weldOptions
             return;
     }
     logger.debug(`simplify: primitive[${index}] of mesh "${mesh.getName()}" → ratio: ${meshOptions.ratio}, error: ${meshOptions.error}, lockBorder: ${meshOptions.lockBorder}`);
-    return simplifyPrimitive(document, prim, meshOptions);
+    return simplifyPrimitive(prim, meshOptions);
 }
 // function updatePrimitive(prim: Primitive, simplifier: any, positionArray, dstIndicesArray) {
 // 	const position = prim.getAttribute('POSITION')!;