@needle-tools/gltf-build-pipeline 1.5.0-alpha.1 → 1.5.0-alpha.11

package/CHANGELOG.md

@@ -4,6 +4,41 @@ 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.5.0-alpha.11] - 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 
+
+## [1.5.0-alpha.8] - 2023-05-16
+- fix: issue where updating ktx compressed texture extension also flattened the path
+
+## [1.5.0-alpha.7] - 2023-05-16
+- fix: external resources that are KTX2 compressed are now saved with a `.ktx2` extension
+- change: toktx now uses compression "auto" mode to select uastc or etc1s 
+- change: toktx now checks the slots and increases quality for `metallicRoughnessTexture` and `normalTexture` but keeps using ETC1S for smaller file size
+
+## [1.5.0-alpha.6] - 2023-05-15
+- fix: If not further specified then automatically use UASTC for textures that are in either `normalTexture` or `metallicRoughnessTexture` slots
+
+## [1.5.0-alpha.5] - 2023-05-04
+- fix: NEEDLE_opaque should handle if VRM texture index is negative
+- change: exit with code 1 if any file packing fails
+
+## [1.5.0-alpha.4] - 2023-05-03
+- fix: issue in NEEDLE_opaque resolving of VRM textures, also resolve `meta.texture`
+- fix: VRMs now compress meshes with mesh-opt if nothing is specified
+- change: include version in cache directory
+
+## [1.5.0-alpha.3] - 2023-05-03
+- add: VRM progressive textures support
+- fix: VRM format should be saved as GLB. See https://github.com/donmccurdy/glTF-Transform/issues/1390
+- fix: VRM texture index handling
+
 ## [1.5.0-alpha] - 2023-05-01
 - add: NEEDLE_opaque `node: <index>` retargeting
 - add: passthrough VRM extension

package/dist/cache/cache.d.ts

@@ -8,7 +8,7 @@ export declare function clearCache(): void;
  * Ensure that the cache size does not exceed the given maximum size in MB.
  * @param maxSizeMB The maximum size in MB.
  */
-export declare function ensureCacheSize(maxSizeMB: number): void;
+export declare function limitCacheSize(maxSizeMB?: number): void;
 /**
  * Add data to the cache.
  * @param key The key to store the data under.
@@ -48,4 +48,4 @@ export declare function getKeyWithHash(property: ExtensibleProperty): {
  * @param property The property to get the hash for.
  * @returns The hash as a number.
  */
-export declare function getHash(property: ExtensibleProperty | object): number;
+export declare function getHash(property: ExtensibleProperty | object, level?: number): number;

package/dist/cache/cache.js

@@ -1,6 +1,6 @@
 import { ExtensibleProperty, Texture, Primitive, Accessor, Mesh } from "@gltf-transform/core";
 import tmp from 'tmp';
-import fs from 'fs';
+import fs, { statSync } from 'fs';
 import path from 'path';
 import { getVersion } from "../utils/version.js";
 // import * as CHECKDISCSPACE from 'check-disk-space'
@@ -24,7 +24,7 @@ const buildPipelineVersion = getVersion(false);
  * This will remove all files in the cache directory.
  */
 export function clearCache() {
-    const dir = getCacheDirectory();
+    const dir = getCacheDirectory(true);
     fs.rmSync(dir, { recursive: true });
     console.log(`Cleared cache at ${dir}`);
 }
@@ -32,16 +32,27 @@ export function clearCache() {
  * Ensure that the cache size does not exceed the given maximum size in MB.
  * @param maxSizeMB The maximum size in MB.
  */
-export function ensureCacheSize(maxSizeMB) {
-    const dir = getCacheDirectory();
+export function limitCacheSize(maxSizeMB = 1024) {
+    const dir = getCacheDirectory(true);
+    console.log(`Limit cache size to ${maxSizeMB.toFixed(2)} MB at ${dir}...`);
     let totalSize = 0;
-    const files = fs.readdirSync(dir).map(file => {
-        const path = `${dir}/${file}`;
-        const stats = fs.statSync(path);
-        totalSize += stats.size;
-        return { path, size: stats.size };
-    });
+    function recurseDirectories(dir) {
+        const files = fs.readdirSync(dir).map(file => {
+            const path = `${dir}/${file}`;
+            const stats = statSync(path);
+            if (stats.isDirectory()) {
+                recurseDirectories(path);
+            }
+            else {
+                totalSize += stats.size;
+            }
+            return { path, size: stats.size };
+        });
+        return files;
+    }
+    const files = recurseDirectories(dir);
     const maxSizeInBytes = maxSizeMB * 1024 * 1024;
+    console.log(`Current cache size is ${(totalSize / (1024 * 1024)).toFixed(1)} MB`);
     if (totalSize < maxSizeInBytes)
         return;
     files.sort((a, b) => {
@@ -55,6 +66,7 @@ export function ensureCacheSize(maxSizeMB) {
         const file = files.shift();
         if (!file)
             break;
+        console.log(`Removing cache file ${file.path}...`);
         fs.rmSync(file.path);
         totalSize -= file.size;
     }
@@ -153,7 +165,7 @@ export function getKeyWithHash(property) {
  * @param property The property to get the hash for.
  * @returns The hash as a number.
  */
-export function getHash(property) {
+export function getHash(property, level = 0) {
     let hash = 0;
     if (property instanceof ExtensibleProperty) {
         const extensions = property.listExtensions();
@@ -175,7 +187,7 @@ export function getHash(property) {
             hash += hashObject(weights);
             const primitives = property.listPrimitives();
             for (const prim of primitives)
-                hash += getHash(prim);
+                hash += getHash(prim, level + 1);
         }
         else if (property instanceof Primitive) {
             const indices = property.getIndices();
@@ -198,8 +210,9 @@ export function getHash(property) {
     }
     return hash;
 }
-function getCacheDirectory() {
-    const tmpDir = path.join(tmp.tmpdir, "Needle", "build-pipeline-cache");
+const cleanBuildPipelineVersion = buildPipelineVersion.replace(/[^a-zA-Z0-9]/g, "_");
+function getCacheDirectory(root) {
+    const tmpDir = path.join(tmp.tmpdir, "Needle", "build-pipeline-cache", root ? "" : cleanBuildPipelineVersion);
     if (!fs.existsSync(tmpDir)) {
         fs.mkdirSync(tmpDir, { recursive: true });
     }
@@ -211,12 +224,7 @@ function hashObject(obj) {
         return hashBuffer(buffer);
     }
     const str = JSON.stringify(obj);
-    let hash = 0;
-    for (let i = 0; i < str.length; i++) {
-        hash = ((hash << 5) - hash) + str.charCodeAt(i);
-        hash |= 0;
-    }
-    return hash;
+    return hashString(str);
 }
 function hashBuffer(buffer, offset, length) {
     let hash = 0;
@@ -227,3 +235,11 @@ function hashBuffer(buffer, offset, length) {
     }
     return hash;
 }
+function hashString(str) {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+        hash = ((hash << 5) - hash) + str.charCodeAt(i);
+        hash |= 0;
+    }
+    return hash;
+}

package/dist/extensions/NEEDLE_compression_texture/NEEDLE_compression_texture.d.ts

@@ -1,7 +1,7 @@
 import { Extension, ExtensionProperty, PropertyType, ReaderContext, WriterContext } from "@gltf-transform/core";
 export declare const EXTENSION_NAME = "NEEDLE_compression_texture";
 export declare interface NEEDLE_compression_texture_schema {
-    mode: string;
+    mode: "none" | "auto" | "webp" | "UASTC" | "ETC1S";
     slot: string;
     /** quality in range of 0 - 1 */
     quality: number;

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

@@ -1,9 +1,10 @@
 import { WriterContext, PropertyType } from '@gltf-transform/core';
 declare interface IExtensibleProperty {
 }
+type DebugBreakPoint = boolean | "pointer:read";
 export type Options = {
     debug?: boolean;
-    breakpoint?: boolean;
+    breakpoint?: DebugBreakPoint;
     write?: boolean;
 };
 export interface IOpaqueExtension {

package/dist/extensions/NEEDLE_opaque/NEEDLE_opaque.js

@@ -19,13 +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;
             for (const type of types) {
                 switch (type) {
                     case PropertyType.ACCESSOR:
@@ -224,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;
@@ -514,6 +515,7 @@ class JsonPointerHandler {
     document;
     map = new Map();
     debug = false;
+    breakPoint = false;
     constructor(document, id) {
         this.document = document;
         this.id = id;
@@ -524,7 +526,11 @@ class JsonPointerHandler {
         if (key !== undefined) {
             fullPath ??= "";
             fullPath += "/" + key;
+            if (this.breakPoint === "pointer:read") {
+                debugger;
+            }
         }
+        // if(this.debug && key === "colliders") debugger;
         switch (typeof value) {
             case 'object':
                 if (value !== null && value !== undefined) {
@@ -556,7 +562,8 @@ class JsonPointerHandler {
                                 console.log("Texture index", index, imageIndex, context.jsonDoc.json.textures.length, "Textures:" + context.textures.length);
                             const object = tryGetInArray(context.textures, imageIndex);
                             if (object) {
-                                const res = new TexturePointerResolver(this.document, object, definition);
+                                const res = new TextureIndexResolver(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(path, res, value);
                                 pointer.debug = this.debug;
@@ -569,7 +576,7 @@ class JsonPointerHandler {
                         if (pointer) {
                             if (this.debug)
                                 console.log("> Register pointer", this.id + "/" + fullPath + " : " + value);
-                            pointer?.register(obj, key);
+                            pointer?.register(obj, key, fullPath);
                         }
                         else
                             console.warn("WARN: failed registering pointer", fullPath, value);
@@ -589,33 +596,80 @@ class JsonPointerHandler {
                             let pointer = this.map.get(value);
                             if (!pointer) {
                                 const definition = context.jsonDoc.json.materials[index];
-                                const res = new MaterialPointerResolver(this.document, mat, definition);
+                                const res = new MaterialIndexResolver(this.document, mat, 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);
                             }
-                            pointer?.register(obj, key);
+                            pointer?.register(obj, key, fullPath);
                         }
                     }
                 }
                 break;
             case 'number':
-                if (key === "node") {
+                if (key === "node" || key === "mesh"
+                    // VRM 1.0 spring bone center https://github.com/vrm-c/vrm-specification/blob/master/specification/VRMC_springBone-1.0/schema/VRMC_springBone.spring.schema.json
+                    || fullPath.match(/springs\/\d+\/center/g)) {
                     const object = context.nodes[value];
                     if (object) {
                         const res = new NodeIndexResolver(this.document, object, context.jsonDoc.json.nodes[value]);
+                        res.debug = this.debug;
                         res.init(context);
-                        const dictKey = "/nodes/" + value;
+                        const dictKey = `/${key}/${value}`;
                         let pointer = this.map.get(dictKey);
                         if (!pointer) {
                             pointer = new JsonPointer(null, res, value);
                         }
                         pointer.debug = this.debug;
-                        pointer.register(obj, key);
+                        pointer.register(obj, key, fullPath);
                         this.map.set(dictKey, pointer);
                     }
                 }
+                else if (
+                // key texture is matching for example for VRM meta/texture (AvatarSample_A)
+                key === "texture"
+                    // VRM 0.0 material properties
+                    || fullPath.match(/materialProperties\/\d+\/textureProperties/g)
+                    // VRM 1.0 meta
+                    || fullPath.match(/meta\/thumbnailImage/g)) {
+                    const index = value;
+                    // e.g. in meta.texture for VRM avatars it seems like we can have negative values
+                    if (index < 0) {
+                        console.warn(`WARN: texture index is negative ${index} at ${fullPath}`);
+                        return;
+                    }
+                    const definition = context.jsonDoc.json.textures[index];
+                    if (!definition) {
+                        console.warn(`WARN: texture definition with index ${index} not found or does not exist. Set in \"${fullPath}\"`);
+                        return;
+                    }
+                    const imageIndex = findSource(definition);
+                    if (this.debug)
+                        console.log("Texture index", index, imageIndex, context.jsonDoc.json.textures.length, "Textures:" + context.textures.length);
+                    const object = tryGetInArray(context.textures, imageIndex);
+                    if (object) {
+                        if (this.debug)
+                            console.log("Found texture index at  " + fullPath + ": " + value);
+                        const res = new TextureIndexResolver(this.document, object, definition);
+                        res.debug = this.debug;
+                        res.init(context);
+                        const dictKey = `/textures/${value}`;
+                        let pointer = this.map.get(dictKey);
+                        if (!pointer) {
+                            pointer = new JsonPointer(null, res, value);
+                        }
+                        pointer.debug = this.debug;
+                        pointer.register(obj, key, fullPath);
+                        this.map.set(dictKey, pointer);
+                        if (ext) {
+                            ext.setReference(dictKey, object);
+                        }
+                    }
+                }
+                break;
+            default:
                 break;
         }
     }
@@ -638,9 +692,11 @@ class JsonPointer {
     }
     _objects = [];
     _props = [];
-    register(obj, prop) {
+    _debugInfo = [];
+    register(obj, prop, fullpath) {
         this._objects.push(obj);
         this._props.push(prop);
+        this._debugInfo.push(fullpath);
     }
     newPointer;
     resolve(context) {
@@ -655,18 +711,19 @@ class JsonPointer {
                 this.newPointer = index;
             }
             if (this.debug)
-                console.log(`RESOLVED ${this.oldPointer} to → ${this.newPointer}`);
+                console.log(`RESOLVED pointer ${this.oldPointer} to → ${this.newPointer}`);
         }
         else {
-            console.log("ERR: failed to resolve pointer", this.pointerBase);
+            console.log("ERR: 🧨 FAILED to resolve pointer", this.pointerBase, ` used by ${this._debugInfo.join(", ")}`);
         }
     }
     write() {
         for (let i = 0; i < this._objects.length; i++) {
             const obj = this._objects[i];
             const prop = this._props[i];
-            if (this.debug)
-                console.log("< Resolved pointer", this.newPointer, "in", prop);
+            if (this.debug) {
+                console.log(`< Resolved pointer ${this._debugInfo[i]}: ${this.newPointer}`);
+            }
             obj[prop] = this.newPointer;
         }
     }
@@ -684,7 +741,7 @@ class PointerResolver {
     }
     debug = false;
 }
-class TexturePointerResolver extends PointerResolver {
+class TextureIndexResolver extends PointerResolver {
     _debugName;
     _samplerDef;
     init(context) {
@@ -719,7 +776,7 @@ class TexturePointerResolver extends PointerResolver {
         // the texture was not found - add it
         // create a new texture def entry
         if (this.debug)
-            console.log("Creating new texture", this._debugName);
+            console.log("Could not find texture, creating a new one: " + this._debugName);
         const hasExtensionWithSource = this.inputDefinition.extensions && Object.keys(this.inputDefinition.extensions).some(key => this.inputDefinition.extensions[key]["source"] !== undefined);
         const textureDef = {
             source: hasExtensionWithSource ? undefined : imgIndex,
@@ -774,7 +831,7 @@ function findSource(texDef) {
     }
     return undefined;
 }
-class MaterialPointerResolver extends PointerResolver {
+class MaterialIndexResolver extends PointerResolver {
     init(context) {
     }
     resolve(context) {

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_opaque/index.js

@@ -17,5 +17,12 @@ export const ALL_EXTENSIONS = [
     createOpaqueExtension("EXT_texture_exr", [PropertyType.TEXTURE], { ...opaqueOptions }),
     createOpaqueExtension("NEEDLE_editor", [PropertyType.NODE, PropertyType.MATERIAL], { ...opaqueOptions }),
     createOpaqueExtension("NEEDLE_gltf_dependencies", [PropertyType.ROOT], { ...opaqueOptions }),
+    // VRM 0.0
     createOpaqueExtension("VRM", [PropertyType.ROOT], { ...opaqueOptions }),
+    // VRM 1.0 https://vrm.dev/en/vrm1/changed/
+    createOpaqueExtension("VRMC_vrm", [PropertyType.ROOT], { ...opaqueOptions }),
+    createOpaqueExtension("VRMC_springBone", [PropertyType.ROOT], { ...opaqueOptions }),
+    createOpaqueExtension("VRMC_node_constraint", [PropertyType.NODE], { ...opaqueOptions }),
+    // TODO: mtoon materials don't work yet
+    // createOpaqueExtension("VRMC_materials_mtoon", [PropertyType.MATERIAL], { ...opaqueOptions, debug: true, breakpoint: "pointer:read" },),
 ];

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/transforms/needle_common.d.ts

@@ -1,6 +1,8 @@
 import { Document, Texture } from '@gltf-transform/core';
 import { NEEDLE_compression_texture_schema } from '../extensions/index.js';
 export interface NeedleTransformContext {
+    /** full path to the file being processed */
+    file: string;
     debug?: boolean;
     useCache: boolean;
     noToktx: boolean;

package/dist/transforms/needle_mesh_transform.d.ts

@@ -1,4 +1,8 @@
 import { Transform, Document, Primitive, Mesh } from "@gltf-transform/core";
 import { SimplifyOptions, WeldOptions } from "@gltf-transform/functions";
-export declare const needle_mesh_transform: (_options: SimplifyOptions) => Transform;
+declare type MeshTransformContext = {
+    file: string;
+};
+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_mesh_transform.js

@@ -3,14 +3,14 @@ import { meshopt, simplifyPrimitive, SIMPLIFY_DEFAULTS, weldPrimitive, WELD_DEFA
 import { MeshoptEncoder, MeshoptSimplifier } from "meshoptimizer";
 import { NEEDLE_mesh_compression } from "../extensions/index.js";
 const NAME = 'needle_mesh_transform';
-export const needle_mesh_transform = function (_options) {
+export const needle_mesh_transform = function (context, simplify) {
     return async (document, _context) => {
         // TODO: needs to be moved into NEEDLE_progressive
-        await simplifierTransform(document, _context, _options);
-        await applyMeshCompression(document, _context);
+        await simplifierTransform(document, _context, simplify);
+        await applyMeshCompression(document, _context, context);
     };
 };
-async function applyMeshCompression(document, _context) {
+async function applyMeshCompression(document, transform_context, context) {
     const rootExtension = document.getRoot().getExtension(NEEDLE_mesh_compression.EXTENSION_NAME);
     if (rootExtension) {
         const rootModel = rootExtension.model;
@@ -22,17 +22,23 @@ async function applyMeshCompression(document, _context) {
             console.log(`[${NAME}]: ${rootModel.compression.toUpperCase()} → will apply ${rootModel.compression} mesh compression`);
             if (rootModel.compression === "draco") {
                 const transform = draco();
-                return transform(document, _context);
+                return transform(document, transform_context);
             }
             else if (rootModel.compression === "meshopt") {
                 const transform = meshopt({ encoder: MeshoptEncoder });
-                return transform(document, _context);
+                return transform(document, transform_context);
             }
         }
     }
+    // If nothing is configured apply meshopt compression as long as we're running gltf-transform 3.x
+    if (context.file.endsWith(".vrm")) {
+        console.log(`[${NAME}]: VRM → will apply meshopt mesh compression`);
+        const transform = meshopt({ encoder: MeshoptEncoder });
+        return transform(document, transform_context);
+    }
     // by default we still want to run draco if the root doesnt have a compression model configured
     console.log(`[${NAME}]: No compression model configured → will apply draco mesh compression`);
-    return draco()(document, _context);
+    return draco()(document, transform_context);
 }
 async function simplifierTransform(document, _context, _options) {
     const simplifier = MeshoptSimplifier;

package/dist/transforms/needle_progressive.js

@@ -7,13 +7,13 @@ import path, { basename } 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";
-import { foreachGLTF, generateGuid } from '../utils/index.js';
+import { detectTextureCompressionMode, foreachGLTF, generateGuid, writeNodeIO } from '../utils/index.js';
 import { needle_asset, writeNeedleAsset } from './needle_asset.js';
 import { MeshoptDecoder, MeshoptSimplifier } from 'meshoptimizer';
 import { compressPrimitive } from './needle_mesh_transform.js';
 import { calculateMeshDensity, getMeshInformation } from "../utils/mesh.js";
 export async function make_progressive(opts) {
-    console.log("INFO: Run progressive transform: " + opts.path);
+    console.log(`INFO: Run progressive transform: ${opts.path}`);
     const file = opts.path;
     return foreachGLTF(file, async (f) => {
         // Don't re-process files that are already LODs
@@ -38,7 +38,7 @@ function registerExtensions(io) {
     ]);
 }
 async function onProcess(file, opts) {
-    if (!file.endsWith(".glb") && !file.endsWith(".gltf")) {
+    if (!file.endsWith(".glb") && !file.endsWith(".gltf") && !file.endsWith(".vrm")) {
         console.log("ERR: file is not gltf/glb");
         return;
     }
@@ -71,7 +71,19 @@ async function onProcess(file, opts) {
             }
             //@ts-ignore
             document.getLogger().verbosity = 0;
-            await document.transform(needle_asset(), make_progressive_textures(file, { size: [256, 256] }, opts), make_progressive_meshes(file, {}, opts), sparse());
+            const transforms = [
+                needle_asset(),
+                make_progressive_textures(file, { size: [256, 256] }, opts),
+                sparse(),
+            ];
+            // TODO: progressive meshes aren't supported yet for VRMs
+            if (!file.endsWith(".vrm")) {
+                transforms.push(make_progressive_meshes(file, {}, opts));
+            }
+            else
+                console.warn("WARN: Progressive meshes are not supported for VRM files yet");
+            console.log("→ Transforming: " + file);
+            await document.transform(...transforms);
             let filename = file;
             if (opts.debug === true) {
                 // get extension
@@ -81,7 +93,8 @@ async function onProcess(file, opts) {
                 // add new extension
                 filename = filename + ".debug." + extension;
             }
-            io.write(filename, document);
+            await writeNodeIO(io, filename, document);
+            console.log("← Transforming done: " + filename);
         }
     }
     catch (err) {
@@ -130,7 +143,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 {
@@ -141,6 +154,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;
@@ -158,7 +175,7 @@ export function make_progressive_textures(filePath, _options = TEXTURE_RESIZE_DE
                 continue;
             }
             const textureGuid = settings.guid?.length ? settings.guid : generateGuid(path + "_texture_" + index.toString());
-            const outPath = createTextureLod(doc, textureLodBasePath, 0, texture, slots, textureGuid, textureIndex);
+            const outPath = createTextureLod(doc, filePath, textureLodBasePath, 0, texture, slots, textureGuid, textureIndex);
             if (!outPath) {
                 continue;
             }
@@ -194,7 +211,7 @@ export function make_progressive_textures(filePath, _options = TEXTURE_RESIZE_DE
         logger.debug(`Progressive transform finished in ${((Date.now() - startTime) / 1000).toFixed(1)} sec.`);
     });
 }
-function createTextureLod(doc, basePath, level, texture, slots, guid, textureIndex) {
+function createTextureLod(doc, file, basePath, level, texture, slots, guid, textureIndex) {
     // const imageBytes = texture.getImage();
     // if (imageBytes) {
     // 	// write bytes
@@ -245,6 +262,13 @@ function createTextureLod(doc, basePath, level, texture, slots, guid, textureInd
         console.log("> Pass compression extension to new texture");
         const newExt = newDoc.createExtension(NEEDLE_compression_texture);
         const def = compressionSettings.getExtensionDefinition();
+        def.mode = detectTextureCompressionMode(slots);
+        def.slot = slots[0];
+        // for VRMS we just use webp
+        // if (file?.toLocaleLowerCase().endsWith(".vrm")) {
+        // 	def.mode = "webp";
+        // 	def.quality = 70;
+        // }
         const newProp = newExt.create(def);
         newTexture.setExtension(NEEDLE_compression_texture.EXTENSION_NAME, newProp);
     }

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 {};