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

package/CHANGELOG.md

@@ -4,6 +4,37 @@ 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.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

@@ -26,6 +26,7 @@ export function createOpaqueExtension(name, types, opts) {
                 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:
@@ -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.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: SimplifyOptions) => 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.js

@@ -5,6 +5,8 @@ import { addToCache, getKey, tryGetFromCache } from "../cache/index.js";
 import { NeedleWebPContext } from "./needle_webp.js";
 import { NeedleToktxContext } from "./needle_toktx.js";
 import { createTransform } from "@gltf-transform/functions";
+import { dirname } from "path";
+import { existsSync, rmSync } from "fs";
 export async function resizeTextureIfNecessary(texture) {
     const ext = texture.getExtension(NEEDLE_compression_texture.EXTENSION_NAME);
     if (ext?.model) {
@@ -74,8 +76,8 @@ export const needle_texture_transform = function (options) {
     });
 };
 async function processTexture(texture, index, document, logger, context) {
-    const mimeType = texture.getMimeType();
-    const isSupported = mimeType === "image/jpeg" || mimeType === "image/png" || mimeType === "image/webp";
+    const originalMimeType = texture.getMimeType();
+    const isSupported = originalMimeType === "image/jpeg" || originalMimeType === "image/png" || originalMimeType === "image/webp";
     // dont try to transform EXR or already processed textures
     if (!isSupported)
         return;
@@ -96,6 +98,7 @@ async function processTexture(texture, index, document, logger, context) {
     }
     let successFullyProcessed = false;
     const canRunToktx = context.noToktx !== true;
+    const originalUri = texture.getURI();
     if (compressionSettings && compressionSettings.mode !== "auto") {
         switch (compressionSettings.mode) {
             case "webp":
@@ -125,21 +128,46 @@ async function processTexture(texture, index, document, logger, context) {
         }
     }
     else {
+        let mimeType = "image/ktx2";
+        // const slots = listTextureSlots(texture);
+        // if (slots.includes("metallicRoughnessTexture"))
+        //     mimeType = "image/webp";
+        const isVRM = context.file?.toLowerCase().endsWith(".vrm");
+        // TODO: need to make this into a function
+        // const webpThreshold = 256; // this is the default threshold in progressive textures (needle_progressive.ts)
+        // console.log(context.file, isVRM);
+        // // if we're dealing with a VRM and the texture size is < 128x128 we can use webp (this is e.g. the case for progressive textures)
+        // if (isVRM) {
+        //     const size = texture.getSize();
+        //     console.log(isVRM, size)
+        //     if (size && size[0] <= webpThreshold && size[1] <= webpThreshold) {
+        //         mimetype = "image/webp";
+        //     }
+        // }
         // If we have a texture cached we can use it
         // the default compression is toktx so we can safely use that for now
         if (cached) {
-            texture.setImage(cached).setMimeType("image/ktx2");
+            texture.setImage(cached).setMimeType(mimeType);
             return;
         }
         await resizeTextureIfNecessary(texture);
-        if (canRunToktx) {
+        if (mimeType === "image/webp") {
+            successFullyProcessed = await context.webPContext.process(index, texture, {
+                quality: .9,
+            });
+        }
+        else if (canRunToktx) {
             // if no specific compression settings are provided we just use the toktx default settings
             // if we ever change what is used for default compression we need to teach the cache to save the mime type
-            successFullyProcessed = await context.toktxContext.process(index, texture, null);
-            // don't add textures to the cache when toktx doesnt run
+            // For VRMs we use ETC1S always
+            let options = null;
+            if (isVRM) {
+                options = { mode: "ETC1S" };
+            }
+            successFullyProcessed = await context.toktxContext.process(index, texture, options);
         }
         else {
-            console.log("toktx is disallowed. Skipping texture compression.");
+            console.log("Toktx not found: Skipping texture compression.");
         }
     }
     if (context.useCache && successFullyProcessed && key) {
@@ -147,4 +175,15 @@ async function processTexture(texture, index, document, logger, context) {
         if (data)
             addToCache(key, data);
     }
+    if (successFullyProcessed) {
+        const newUri = texture.getURI();
+        if (originalUri && originalUri != newUri) {
+            const fileDirectory = dirname(context.file);
+            const originalPath = fileDirectory + "/" + originalUri;
+            if (existsSync(originalPath)) {
+                console.log(`INFO: Texture moved \"${originalUri}\" → \"${newUri}\"`);
+                rmSync(originalPath);
+            }
+        }
+    }
 }

package/dist/transforms/needle_toktx.d.ts

@@ -20,6 +20,6 @@ export declare class NeedleToktxContext implements INeedleTextureTransformContex
     private _prepareFailed;
     constructor(options: NeedleToktxOptions);
     prepare(document: Document): Promise<boolean>;
-    process(index: number, texture: Texture, settings: NEEDLE_compression_texture_schema | null): Promise<boolean>;
+    process(index: number, texture: Texture, settings: Pick<NEEDLE_compression_texture_schema, "mode"> | null): Promise<boolean>;
     finalize(document: Document): Promise<void>;
 }

package/dist/transforms/needle_toktx.js

@@ -8,6 +8,7 @@ import fs from 'fs/promises';
 import os from 'os';
 import tmp from 'tmp';
 import pLimit from 'p-limit';
+import { replaceExtension } from "../utils/fileutils.js";
 const NUM_CPUS = os.cpus().length || 1; // microsoft/vscode#112122
 let didLogEnvironmentInfo = false;
 export class NeedleToktxContext {
@@ -113,17 +114,39 @@ export class NeedleToktxContext {
             const outPath = tmpName + '.ktx2';
             // const inBytes = image.byteLength;
             await fs.writeFile(inPath, Buffer.from(image));
+            let mode = Mode.ETC1S;
+            let quality = 128;
+            let compression = 1;
+            if (settings) {
+                if (settings.mode === "auto") {
+                    const useUASTC = slots.includes("normalTexture") || slots.includes("metallicRoughnessTexture");
+                    mode = useUASTC ? Mode.UASTC : Mode.ETC1S;
+                }
+                else {
+                    mode = settings.mode === "ETC1S" ? Mode.ETC1S : Mode.UASTC;
+                }
+            }
+            else if (slots) {
+                const isNormal = slots.includes("normalTexture");
+                const isMetallicRoughness = slots.includes("metallicRoughnessTexture");
+                const betterQuality = isNormal || isMetallicRoughness;
+                // mode = useUASTC ? Mode.UASTC : Mode.ETC1S;
+                mode = Mode.ETC1S;
+                // if (isMetallicRoughness) mode = Mode.UASTC;
+                // https://github.khronos.org/KTX-Software/ktxtools/toktx.html
+                quality = betterQuality ? 255 : 128;
+                // ETC1S / BasisLZ compression level, an encoding speed vs. quality tradeoff. Range is [0,5], default is 1. Higher values are slower but give higher quality.
+                compression = betterQuality ? 4 : 1;
+            }
+            const defaults = mode === Mode.ETC1S ? ETC1S_DEFAULTS : UASTC_DEFAULTS;
             //@ts-ignore
-            const defaults = (!settings || settings.mode === "ETC1S") ? ETC1S_DEFAULTS : UASTC_DEFAULTS;
-            defaults.mode = (!settings || settings.mode === "ETC1S") ? Mode.ETC1S : Mode.UASTC;
-            //@ts-ignore
-            const toktxParams = createParams(slots, channels, size, logger, this.numTextures, { ...defaults }, this.version);
+            const toktxParams = createParams(slots, channels, size, logger, this.numTextures, { ...defaults, mode, quality, compression }, this.version);
             const params = [
                 ...toktxParams,
                 outPath,
                 inPath,
             ];
-            logger.debug(`${prefix}: Spawning → toktx ${params.join(' ')}`);
+            logger.debug(`${prefix}: Spawning → toktx ${mode.toUpperCase()} ${params.join(' ')}`);
             try {
                 // COMPRESS: Run `toktx` CLI tool.
                 // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -135,6 +158,13 @@ export class NeedleToktxContext {
                 else {
                     const result = await fs.readFile(outPath);
                     texture.setImage(result).setMimeType('image/ktx2');
+                    // TODO: we also need to remove the old file when the extension has changed - this should probably be done outside of this method to also support webp
+                    // If this is a texture that was loaded from a file, we need to update the URI
+                    if (texture.getURI()) {
+                        const oldUri = texture.getURI();
+                        const newUri = replaceExtension(oldUri, 'ktx2');
+                        texture.setURI(newUri);
+                    }
                     return true;
                 }
             }

package/dist/transforms/needle_webp.d.ts

@@ -8,6 +8,6 @@ export declare class NeedleWebPContext implements INeedleTextureTransformContext
     logger: ILogger;
     constructor(options: NeedleWebPOptions);
     prepare(document: Document): Promise<void>;
-    process(index: number, texture: Texture, settings: NEEDLE_compression_texture_schema): Promise<boolean>;
+    process(index: number, texture: Texture, settings: Pick<NEEDLE_compression_texture_schema, "quality">): Promise<boolean>;
     finalize(document: Document): Promise<void>;
 }

package/dist/utils/compression_utils.d.ts

@@ -0,0 +1,2 @@
+export declare type TextureCompressionMode = "webp" | "ETC1S" | "UASTC";
+export declare function detectTextureCompressionMode(slots: string[]): "ETC1S" | "UASTC";

package/dist/utils/compression_utils.js

@@ -0,0 +1,6 @@
+export function detectTextureCompressionMode(slots) {
+    if (slots.includes("normalTexture") || slots.includes("metallicRoughnessTexture")) {
+        return "UASTC";
+    }
+    return "ETC1S";
+}

package/dist/utils/fileutils.d.ts

@@ -1,2 +1,3 @@
 export declare type GLTFFileCallback = (file: string) => void | Promise<void>;
 export declare function foreachGLTF(args: string | string[], callback: GLTFFileCallback): Promise<void>;
+export declare function replaceExtension(filepath: string, newExtension: string): string;

package/dist/utils/fileutils.js

@@ -89,7 +89,7 @@ async function testEntry(entry, callback, context) {
             }
         }
     }
-    if (entry.endsWith(".glb") || entry.endsWith(".gltf")) {
+    if (entry.endsWith(".glb") || entry.endsWith(".gltf") || entry.endsWith(".vrm")) {
         context.filesFound += 1;
         const res = callback(entry);
         if (res instanceof Promise) {
@@ -113,3 +113,8 @@ async function testEntry(entry, callback, context) {
         }
     }
 }
+export function replaceExtension(filepath, newExtension) {
+    const parts = filepath.split(".");
+    parts.pop();
+    return parts.join(".") + "." + newExtension;
+}

package/dist/utils/index.d.ts

@@ -1,4 +1,6 @@
+export * from "./compression_utils.js";
 export * from "./fileutils.js";
 export * from "./version.js";
 export * from "./mesh.js";
 export * from "./guid.js";
+export * from "./nodeio.js";

package/dist/utils/index.js

@@ -1,4 +1,6 @@
+export * from "./compression_utils.js";
 export * from "./fileutils.js";
 export * from "./version.js";
 export * from "./mesh.js";
 export * from "./guid.js";
+export * from "./nodeio.js";

package/dist/utils/nodeio.d.ts

@@ -0,0 +1,5 @@
+import { NodeIO, Document } from "@gltf-transform/core";
+/**
+ * Handle writing glTf, GLB and VRM files
+ */
+export declare function writeNodeIO(nodeio: NodeIO, filename: string, document: Document): Promise<string>;

package/dist/utils/nodeio.js

@@ -0,0 +1,14 @@
+import { writeFile } from "fs/promises";
+/**
+ * Handle writing glTf, GLB and VRM files
+ */
+export async function writeNodeIO(nodeio, filename, document) {
+    // see https://github.com/donmccurdy/glTF-Transform/issues/1390
+    if (filename.endsWith(".vrm")) {
+        const bin = await nodeio.writeBinary(document);
+        await writeFile(filename, bin);
+    }
+    else
+        await nodeio.write(filename, document);
+    return filename;
+}

package/limit-caches.mjs

@@ -0,0 +1,4 @@
+
+import { limitCacheSize } from './dist/cache/index.js';
+
+limitCacheSize(512);

package/pack-gltf.mjs

@@ -12,7 +12,8 @@ import { needle_animation_transform } from "./dist/transforms/needle_animation_t
 import { foreachGLTF } from './fileutils.mjs';
 import { needle_asset } from './dist/transforms/needle_asset.js';
 import { MeshoptDecoder, MeshoptEncoder } from 'meshoptimizer';
-import { getVersion, getHash, addToCache, tryGetFromCache, isLOD, ensureCacheSize as ensureMaxCacheSize, isMeshLOD } from './dist/index.js';
+import { getVersion, getHash, addToCache, tryGetFromCache, isLOD, limitCacheSize, isMeshLOD } from './dist/index.js';
+import { writeNodeIO } from './dist/utils/nodeio.js';
 
 console.log(`[Needle Build Pipeline] pack glTF — version ${getVersion()}`)
 
@@ -59,11 +60,9 @@ if (debug) {
 
 let allowCaching = true;
 if (args.includes("--no-caching")) {
-    console.log("Caching is disabled")
     allowCaching = false;
 }
-else if (showHelp)
-    console.log("Caching is enabled, use \"--no-caching\" to disable it");
+else console.log("Use --no-caching to disable caching");
 
 const noToktx = args.includes("no-toktx");
 if (noToktx)
@@ -105,10 +104,11 @@ async function packFile(file) {
 
     if (packedFiles.has(file)) return;
     packedFiles.add(file);
-    console.log("→ Begin packing: " + file);
 
     try {
         const prevSizeInMB = statSync(file).size / 1024 / 1024;
+        console.log(`→ Compressing ${prevSizeInMB.toFixed(1)} MB: ${file}`);
+
         const startTime = Date.now();
         const io = new NodeIO()
             .registerExtensions(ALL_EXTENSIONS)
@@ -129,17 +129,19 @@ async function packFile(file) {
         await document.transform(
             needle_asset(),
             needle_texture_transform({
+                file,
                 useCache: allowCaching,
                 noToktx: noToktx,
                 debug: debug,
                 reportGPUMemory: val => totalGPUTextureMemmory += val
             }),
-            needle_mesh_transform({ ratio: 0.75, error: 0.0005 }),
+            needle_mesh_transform({ file }, { ratio: 0.75, error: 0.0005 }),
             needle_animation_transform(),
             // draco(),
         );
         if (debug) file += ".debug.glb";
-        await io.write(file, document);
+
+        await writeNodeIO(io, file, document);
 
         if (allowCaching && cacheKey != undefined && existsSync(file))
             addToCache(cacheKey, readFileSync(file));
@@ -167,18 +169,20 @@ async function packFile(file) {
 
 let startTime = Date.now();
 const inputArgs = args.slice(2);
+let failed = false;
 foreachGLTF(inputArgs, async (file) => {
-    await packFile(file);
+    const res = await packFile(file);
+    if (!res) failed = true;
 }).then(async () => {
     const duration = Date.now() - startTime;
     const durationInMinutes = duration / 1000 / 60;
     if (allowCaching) {
-        // if the user's cache directory has more than 25GB free space, we allow a cache of 2 GB - otherwise 1 GB
-        // const freeSpaceInMB = (await getCacheAvailableSpaceOnDisc().catch(() => 0)) / 1024 / 1024;
-        // const maxCacheSize = freeSpaceInMB > 25000 ? 2000 : 1000;
-        ensureMaxCacheSize(1000);
+        limitCacheSize();
     }
     console.log(`[Needle Build Pipeline] v${getVersion()} — Finished packing ${totalFilesProcessed} files in ${durationInMinutes.toFixed(1)} minutes; total size ${totalFileSizeInMBBefore.toFixed(1)} MB → ${totalFileSizeInMB.toFixed(1)} MB, total GPU memory: ${totalGPUMemoryInMB.toFixed(1)} MB`);
+    if (failed) {
+        process.exit(1);
+    }
 }).catch(err => {
     console.error("ERR: packing failed: " + err.message);
     if (debug) throw err;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@needle-tools/gltf-build-pipeline",
-  "version": "1.5.0-alpha",
+  "version": "1.5.0-alpha.10",
   "description": "Pipeline and tools for optimizing gltf files using gltf-transform and compression settings within glTF extensions",
   "main": "index.mjs",
   "type": "module",
@@ -13,6 +13,7 @@
     "pack-gltf": "node --no-experimental-fetch pack-gltf.mjs",
     "dev:pack-gltf": "npm run compile && node pack-gltf.mjs",
     "clear-caches": "node clear-caches.mjs",
+    "limit-caches": "node limit-caches.mjs",
     "compile": "tsc || exit 1"
   },
   "dependencies": {

package/dist/functions/gzip.d.ts

@@ -1 +0,0 @@
-export declare function gzipFile(filepath: string): Promise<string>;

package/dist/functions/gzip.js

@@ -1,16 +0,0 @@
-import { promises as fs, existsSync } from 'fs';
-import { gzip } from 'node-gzip';
-export async function gzipFile(filepath) {
-    if (filepath.endsWith('.gz')) {
-        return filepath;
-    }
-    if (!existsSync(filepath)) {
-        console.log("File not found: " + filepath);
-        return filepath;
-    }
-    const inBuffer = await fs.readFile(filepath);
-    const outBuffer = await gzip(inBuffer);
-    const outPath = filepath;
-    await fs.writeFile(outPath, outBuffer);
-    return outPath;
-}

package/dist/functions/index.d.ts

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

package/dist/functions/index.js

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

package/dist/functions/list-texture-slots.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/functions/list-texture-slots.js

@@ -1,35 +0,0 @@
-export {};
-// TODO: remove once this is resolved: https://github.com/donmccurdy/glTF-Transform/issues/855
-// modified to take a document as a parameter
-// export function listTextureSlots(texture: Texture, document: Document): string[] {
-//     const root = document.getRoot();
-//     const slots = texture
-//         .getGraph()
-//         .listParentEdges(texture)
-//         .filter((edge) => edge.getParent() !== root)
-//         .map((edge) => edge.getName());
-//     return Array.from(new Set(slots));
-// }
-// export function getTextureChannelMask(texture: Texture, document: Document): number {
-//     let mask = 0x0000;
-//     for (const edge of document.getGraph().listParentEdges(texture)) {
-//         const parent = edge.getParent();
-//         let { channels } = edge.getAttributes() as { channels: number | undefined };
-//         if (
-//             channels &&
-//             edge.getName() === 'baseColorTexture' &&
-//             parent instanceof Material &&
-//             parent.getAlphaMode() === Material.AlphaMode.OPAQUE
-//         ) {
-//             channels &= ~TextureChannel.A;
-//         }
-//         if (channels) {
-//             mask |= channels;
-//             continue;
-//         }
-//         if (parent.propertyType !== PropertyType.ROOT) {
-//             document.getLogger().warn(`Missing attribute ".channels" on edge, "${edge.getName()}".`);
-//         }
-//     }
-//     return mask;
-// }

package/dist/transforms/needle_simplify.d.ts

@@ -1,3 +0,0 @@
-import { Transform } from "@gltf-transform/core";
-import { SimplifyOptions } from "@gltf-transform/functions";
-export declare const needle_mesh_transform: (options: SimplifyOptions) => Transform;

package/dist/transforms/needle_simplify.js

@@ -1,76 +0,0 @@
-import { Primitive } from "@gltf-transform/core";
-import { simplifyPrimitive, weldPrimitive } from "@gltf-transform/functions";
-import { MeshoptSimplifier } from "meshoptimizer";
-import { NEEDLE_mesh_compression } from "../extensions/index.js";
-const NAME = 'needle_simplify';
-export const needle_mesh_transform = function (options) {
-    const simplifier = MeshoptSimplifier;
-    if (!simplifier) {
-        throw new Error(`${NAME}: simplifier dependency required — install "meshoptimizer".`);
-    }
-    return (document, _context) => {
-        const logger = document.getLogger();
-        options = { ...options, simplifier: simplifier };
-        const weldOptions = {
-            tolerance: 0.00000000001,
-            overwrite: true
-        };
-        for (const mesh of document.getRoot().listMeshes()) {
-            for (const prim of mesh.listPrimitives()) {
-                // const key = getKey(prim);
-                // const cached = tryGetFromCache(key);
-                // if (cached) {
-                //     logger.debug(`${NAME}: Skipping primitive of mesh "${mesh.getName()}": Already cached.`);
-                //     continue;
-                // }
-                // updatePrimitive(prim, simplifier, null, prim.getIndices());
-                // continue;
-                const ext = prim.getExtension(NEEDLE_mesh_compression.EXTENSION_NAME);
-                if (!ext) {
-                    // logger.warn("Skipping primitive of mesh " + mesh.getName() + ": No NEEDLE_compression_mesh extension.");
-                    continue;
-                }
-                let meshOptions = { ...options };
-                if (ext.model) {
-                    const model = ext.model;
-                    if (!model.useSimplifier) {
-                        logger.debug(`${NAME}: Skipping primitive of mesh "${mesh.getName()}": useSimplifier is false.`);
-                        continue;
-                    }
-                    if (model.error >= 0)
-                        meshOptions.error = model.error;
-                    if (model.ratio >= 0)
-                        meshOptions.ratio = model.ratio;
-                    meshOptions.lockBorder = model.lockBorder;
-                }
-                if (prim.getMode() !== Primitive.Mode.TRIANGLES) {
-                    logger.warn(`${NAME}: Skipping primitive of mesh "${mesh.getName()}": Requires TRIANGLES draw mode.`);
-                    continue;
-                }
-                logger.debug(`${NAME}: Welding primitive of mesh "${mesh.getName()}" → tolerance: ${weldOptions.tolerance}`);
-                weldPrimitive(document, prim, weldOptions);
-                logger.debug(`${NAME}: Simplifying primitive of mesh "${mesh.getName()}" → ratio: ${meshOptions.ratio}, error: ${meshOptions.error}, lockBorder: ${meshOptions.lockBorder}`);
-                simplifyPrimitive(document, prim, meshOptions);
-            }
-        }
-    };
-};
-// function updatePrimitive(prim: Primitive, simplifier: any, positionArray, dstIndicesArray) {
-// 	const position = prim.getAttribute('POSITION')!;
-// 	const srcIndices = prim.getIndices()!;
-// 	const srcVertexCount = position.getCount();
-//     const [remap, unique] = simplifier.compactMesh(dstIndicesArray);
-//     // logger.debug(`${NAME}: ${formatDeltaOp(position.getCount(), unique)} vertices, error: ${error.toFixed(4)}.`);
-//     // (3) Write vertex attributes.
-//     for (const srcAttribute of deepListAttributes(prim)) {
-//         const dstAttribute = srcAttribute.clone();
-//         remapAttribute(dstAttribute, remap, unique);
-//         deepSwapAttribute(prim, srcAttribute, dstAttribute);
-//         if (srcAttribute.listParents().length === 1) srcAttribute.dispose();
-//     }
-//     // (4) Write indices.
-//     const dstIndices = srcIndices.clone();
-//     dstIndices.setArray(srcVertexCount <= 65534 ? new Uint16Array(dstIndicesArray) : dstIndicesArray);
-//     prim.setIndices(dstIndices);
-//     if (srcIndices.listParents().length === 1) srcIndices.dispose();
-// }

package/dist/transforms/types/squoosh.d.ts

@@ -1,31 +0,0 @@
-export declare class WebPEncoderOptions {
-    quality: number;
-    target_size: number;
-    target_PSNR: number;
-    method: number;
-    sns_strength: number;
-    filter_strength: number;
-    filter_sharpness: number;
-    /** 1 = strong filter */
-    filter_type: number;
-    partitions: number;
-    segments: number;
-    pass: number;
-    show_compressed: number;
-    preprocessing: number;
-    autofilter: number;
-    partition_limit: number;
-    alpha_compression: number;
-    alpha_filtering: number;
-    alpha_quality: number;
-    lossless: number;
-    exact: number;
-    image_hint: number;
-    emulate_jpeg_size: number;
-    thread_level: number;
-    low_memory: number;
-    near_lossless: number;
-    use_delta_palette: number;
-    /** probably sharp rgb -> YUV conversion */
-    use_sharp_yuv: number;
-}

package/dist/transforms/types/squoosh.js

@@ -1,33 +0,0 @@
-// client: https://github.com/GoogleChromeLabs/squoosh/blob/97d13de273b67ee01a80cb32161f1bb2103b73cb/src/features/encoders/webP/client/index.tsx#L292
-// emscripten bindings: 
-export class WebPEncoderOptions {
-    quality = 75;
-    target_size = 0;
-    target_PSNR = 0;
-    method = 4;
-    sns_strength = 50;
-    filter_strength = 60;
-    filter_sharpness = 0;
-    /** 1 = strong filter */
-    filter_type = 1;
-    partitions = 0;
-    segments = 4;
-    pass = 1;
-    show_compressed = 0;
-    preprocessing = 0;
-    autofilter = 0;
-    partition_limit = 0;
-    alpha_compression = 1;
-    alpha_filtering = 1;
-    alpha_quality = 100;
-    lossless = 0;
-    exact = 0;
-    image_hint = 0;
-    emulate_jpeg_size = 0;
-    thread_level = 0;
-    low_memory = 0;
-    near_lossless = 100;
-    use_delta_palette = 0;
-    /** probably sharp rgb -> YUV conversion */
-    use_sharp_yuv = 0;
-}