@needle-tools/gltf-build-pipeline 1.3.1 → 1.4.1-beta

package/CHANGELOG.md

@@ -4,6 +4,14 @@ 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.4.1-beta] - 2023-03-13
+- change: update gltf-transform to `^3.10.0`
+- change: progressive mesh transform does now set ratio for LODs (see [simplifier issue 661 on github](https://github.com/zeux/meshoptimizer/issues/661))
+- fix: issue where progressive meshes were not generated if a mesh was multiple times in the glTF
+
+## [1.4.0-beta] - 2023-03-12
+- add: progressive mesh transform to automatically generate mesh LOD levels (currently we only generate one low poly version)
+
 ## [1.3.1] - 2023-10-20
 - fix: meshopt with khr_animation_2 extension was not correctly processed: animated node and target were not passed to gltf-transform which caused a wrong processing of meshopt. We now pass this information to the gltf-transform AnimationChannel object
 - change: bump gltf-transform to 3.7.3

package/dist/extensions/NEEDLE_mesh_compression/NEEDLE_mesh_compression.d.ts

@@ -1,4 +1,4 @@
-import { Extension, ExtensionProperty, PropertyType, ReaderContext } from "@gltf-transform/core";
+import { Extension, ExtensionProperty, PropertyType, ReaderContext, WriterContext } from "@gltf-transform/core";
 export declare class NEEDLE_mesh_compression_model_root {
     compression: "none" | "draco" | "meshopt";
 }
@@ -13,7 +13,7 @@ export declare class NEEDLE_mesh_compression extends Extension {
     extensionName: string;
     create(model: NEEDLE_mesh_compression_model | NEEDLE_mesh_compression_model_root): NEEDLE_mesh_compression_property;
     read(context: ReaderContext): this;
-    write(ctx: any): this;
+    write(ctx: WriterContext): this;
 }
 export declare class NEEDLE_mesh_compression_property extends ExtensionProperty {
     static EXTENSION_NAME: string;
@@ -22,4 +22,5 @@ export declare class NEEDLE_mesh_compression_property extends ExtensionProperty
     propertyType: string;
     init(): void;
     model: NEEDLE_mesh_compression_model | NEEDLE_mesh_compression_model_root;
+    copy(other: this, resolve?: (property: ExtensionProperty) => ExtensionProperty): this;
 }

package/dist/extensions/NEEDLE_mesh_compression/NEEDLE_mesh_compression.js

@@ -44,6 +44,28 @@ export class NEEDLE_mesh_compression extends Extension {
         return this;
     }
     write(ctx) {
+        const root = this.document.getRoot();
+        const rootExtension = root.getExtension(EXTENSION_NAME);
+        if (rootExtension) {
+            ctx.jsonDoc.json.extensions = ctx.jsonDoc.json.extensions || {};
+            ctx.jsonDoc.json.extensions[EXTENSION_NAME] = rootExtension.model;
+        }
+        for (const mesh of root.listMeshes()) {
+            const index = ctx.meshIndexMap.get(mesh);
+            const meshDef = ctx.jsonDoc.json.meshes[index];
+            const primitives = mesh.listPrimitives();
+            for (let i = 0; i < primitives.length; i++) {
+                const primitive = primitives[i];
+                const ext = primitive.getExtension(EXTENSION_NAME);
+                if (ext) {
+                    const prim = meshDef.primitives[i];
+                    if (prim) {
+                        prim.extensions = meshDef.extensions || {};
+                        prim.extensions[EXTENSION_NAME] = ext.model;
+                    }
+                }
+            }
+        }
         return this;
     }
 }
@@ -54,4 +76,8 @@ export class NEEDLE_mesh_compression_property extends ExtensionProperty {
     propertyType = EXTENSION_NAME;
     init() { }
     model;
+    copy(other, resolve = null) {
+        this.model = { ...other.model };
+        return super.copy(other, resolve);
+    }
 }

package/dist/extensions/NEEDLE_opaque/NEEDLE_opaque.js

@@ -415,7 +415,7 @@ class TextureHandler {
             }
         });
         if (foundTexture === false) {
-            if (this.key !== "EXT_texture_exr" || this.debug)
+            if (this.key !== "EXT_texture_exr" && this.debug)
                 console.warn("WARN: failed to re-assign extension:", this.key, this.index, this.tryGetSourceIndex(this.textureDefinition), textureDefs.length);
         }
         // this.document

package/dist/extensions/NEEDLE_opaque/index.js

@@ -13,6 +13,6 @@ export const ALL_EXTENSIONS = [
     createOpaqueExtension("NEEDLE_lightmaps", PropertyType.ROOT, { ...opaqueOptions }),
     createOpaqueExtension("NEEDLE_lighting_settings", PropertyType.ROOT, { ...opaqueOptions }),
     createOpaqueExtension("NEEDLE_render_objects", PropertyType.ROOT, { ...opaqueOptions }),
-    createOpaqueExtension("NEEDLE_progressive", [PropertyType.TEXTURE, PropertyType.MATERIAL], { ...opaqueOptions }),
+    createOpaqueExtension("NEEDLE_progressive", [PropertyType.TEXTURE, PropertyType.MATERIAL, PropertyType.MESH], { ...opaqueOptions }),
     createOpaqueExtension("EXT_texture_exr", [PropertyType.TEXTURE], { ...opaqueOptions }),
 ];

package/dist/extensions/NEEDLE_progressive/NEEDLE_progressive.d.ts

@@ -1,14 +1,14 @@
-import { Extension, ExtensionProperty, PropertyType, ReaderContext, WriterContext } from "@gltf-transform/core";
-export declare const NEEDLE_PROGRESSIVE_TEXTURE_EXTENSION_NAME = "NEEDLE_progressive";
+import { Extension, ExtensionProperty, Graph, IProperty, Property, PropertyType, ReaderContext, WriterContext } from "@gltf-transform/core";
+export declare const NEEDLE_PROGRESSIVE_EXTENSION_NAME = "NEEDLE_progressive";
 export declare interface IProgressiveTextureInfo {
-    uri?: string;
     guid: string;
-    level?: number;
+    uri?: string | Array<string>;
 }
 export declare function generateGuid(): string;
 export declare class NEEDLE_progressive extends Extension {
     static EXTENSION_NAME: string;
     extensionName: string;
+    static create(graph: Graph<Property<IProperty>>, data: IProgressiveTextureInfo): NEEDLE_progressive_texture_property;
     create(data: IProgressiveTextureInfo): NEEDLE_progressive_texture_property;
     read(_context: ReaderContext): this;
     write(context: WriterContext): this;

package/dist/extensions/NEEDLE_progressive/NEEDLE_progressive.js

@@ -1,52 +1,70 @@
 import { Extension, ExtensionProperty, PropertyType, uuid } from "@gltf-transform/core";
 // TODO: rename to NEEDLE_progressive_texture
-export const NEEDLE_PROGRESSIVE_TEXTURE_EXTENSION_NAME = "NEEDLE_progressive";
+export const NEEDLE_PROGRESSIVE_EXTENSION_NAME = "NEEDLE_progressive";
 export function generateGuid() {
     // TODO: replace with same uuid package as in needle engine
     return uuid();
 }
 export class NEEDLE_progressive extends Extension {
-    static EXTENSION_NAME = NEEDLE_PROGRESSIVE_TEXTURE_EXTENSION_NAME;
-    extensionName = NEEDLE_PROGRESSIVE_TEXTURE_EXTENSION_NAME;
-    create(data) {
-        const ext = new NEEDLE_progressive_texture_property(this.document.getGraph());
+    static EXTENSION_NAME = NEEDLE_PROGRESSIVE_EXTENSION_NAME;
+    extensionName = NEEDLE_PROGRESSIVE_EXTENSION_NAME;
+    static create(graph, data) {
+        const ext = new NEEDLE_progressive_texture_property(graph);
         ext.model = data;
         return ext;
     }
+    create(data) {
+        return NEEDLE_progressive.create(this.document.getGraph(), data);
+    }
     read(_context) {
         // console.log("READ " + NEEDLE_PROGRESSIVE_TEXTURE_EXTENSION_NAME);
         return this;
     }
     write(context) {
         // console.log("WRITE " + NEEDLE_PROGRESSIVE_TEXTURE_EXTENSION_NAME);
-        const textureDefinitions = context.jsonDoc.json.textures;
-        if (!textureDefinitions)
-            return;
         const root = this.document.getRoot();
-        const textures = root.listTextures();
-        // we use the texture image map to find the texture definition to write the extension to
-        const textureImageIndexMap = context.imageIndexMap;
-        for (const tex of textures) {
-            const prop = tex.getExtension(NEEDLE_PROGRESSIVE_TEXTURE_EXTENSION_NAME);
-            if (prop && prop.model) {
-                // get the image this texture is using
-                const imageIndex = textureImageIndexMap.get(tex);
-                // find the texture definition that uses this image and add the extension
-                for (const def of textureDefinitions) {
-                    if (def.source === imageIndex) {
-                        def.extensions = def.extensions || {};
-                        def.extensions[NEEDLE_PROGRESSIVE_TEXTURE_EXTENSION_NAME] = prop.model;
+        const textureDefinitions = context.jsonDoc.json.textures;
+        if (textureDefinitions.length) {
+            const textures = root.listTextures();
+            // we use the texture image map to find the texture definition to write the extension to
+            const textureImageIndexMap = context.imageIndexMap;
+            for (const tex of textures) {
+                const prop = tex.getExtension(NEEDLE_PROGRESSIVE_EXTENSION_NAME);
+                if (prop && prop.model) {
+                    // get the image this texture is using
+                    const imageIndex = textureImageIndexMap.get(tex);
+                    // find the texture definition that uses this image and add the extension
+                    for (const def of textureDefinitions) {
+                        if (def.source === imageIndex) {
+                            def.extensions = def.extensions || {};
+                            def.extensions[NEEDLE_PROGRESSIVE_EXTENSION_NAME] = prop.model;
+                        }
                     }
                 }
             }
         }
+        const meshDefinitions = context.jsonDoc.json.meshes;
+        if (meshDefinitions?.length) {
+            const meshIndexMap = context.meshIndexMap;
+            const meshes = root.listMeshes();
+            for (let i = 0; i < meshes.length; i++) {
+                const mesh = meshes[i];
+                const meshIndex = meshIndexMap.get(mesh);
+                const meshExt = mesh.getExtension(NEEDLE_PROGRESSIVE_EXTENSION_NAME);
+                if (meshExt && meshExt.model) {
+                    const meshDef = meshDefinitions[meshIndex];
+                    meshDef.extensions = meshDef.extensions || {};
+                    meshDef.extensions[NEEDLE_PROGRESSIVE_EXTENSION_NAME] = meshExt.model;
+                }
+            }
+        }
         return this;
     }
 }
 export class NEEDLE_progressive_texture_property extends ExtensionProperty {
-    static EXTENSION_NAME = NEEDLE_PROGRESSIVE_TEXTURE_EXTENSION_NAME;
-    extensionName = NEEDLE_PROGRESSIVE_TEXTURE_EXTENSION_NAME;
-    parentTypes = [PropertyType.TEXTURE];
+    static EXTENSION_NAME = NEEDLE_PROGRESSIVE_EXTENSION_NAME;
+    extensionName = NEEDLE_PROGRESSIVE_EXTENSION_NAME;
+    parentTypes = [PropertyType.TEXTURE, PropertyType.MESH];
     propertyType = "progressive_texture";
     init() { }
     model;

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

@@ -0,0 +1,20 @@
+import { Extension, ExtensionProperty, PropertyType, ReaderContext, WriterContext } from "@gltf-transform/core";
+export declare interface IProgressiveMeshSettings {
+    guid: string;
+}
+export declare class NEEDLE_progressive_mesh_settings extends Extension {
+    static EXTENSION_NAME: string;
+    extensionName: string;
+    read(context: ReaderContext): this;
+    write(context: WriterContext): this;
+}
+export declare class NEEDLE_progressive_mesh_settings_property extends ExtensionProperty implements IProgressiveMeshSettings {
+    static EXTENSION_NAME: string;
+    readonly extensionName: string;
+    parentTypes: PropertyType[];
+    propertyType: string;
+    init(): void;
+    get isValid(): boolean;
+    maxSize: number;
+    guid: string;
+}

package/dist/extensions/NEEDLE_progressive_mesh_settings/index.js

@@ -0,0 +1,44 @@
+import { Extension, ExtensionProperty, PropertyType } from "@gltf-transform/core";
+const EXTENSION_NAME = "NEEDLE_progressive_mesh_settings";
+export class NEEDLE_progressive_mesh_settings extends Extension {
+    static EXTENSION_NAME = EXTENSION_NAME;
+    extensionName = EXTENSION_NAME;
+    read(context) {
+        const definitions = context.jsonDoc.json.meshes;
+        if (!definitions)
+            return this;
+        const root = this.document.getRoot();
+        const meshes = root.listMeshes();
+        for (let i = 0; i < definitions.length; i++) {
+            const def = definitions[i];
+            if (def.extensions && def.extensions[EXTENSION_NAME]) {
+                const ext = def.extensions[EXTENSION_NAME];
+                const prop = new NEEDLE_progressive_mesh_settings_property(this.document.getGraph(), "");
+                Object.assign(prop, ext);
+                let index = i;
+                const mesh = meshes[index];
+                if (mesh)
+                    mesh.setExtension(EXTENSION_NAME, prop);
+                else {
+                    console.warn(`WARN: Progressive mesh at index ${i} was not found in the glTF file. This might result in falsely loaded textures for ${ext.guid} / name \"${def.name}\"`);
+                }
+            }
+        }
+        return this;
+    }
+    write(context) {
+        return this;
+    }
+}
+export class NEEDLE_progressive_mesh_settings_property extends ExtensionProperty {
+    static EXTENSION_NAME = EXTENSION_NAME;
+    extensionName = EXTENSION_NAME;
+    parentTypes = [PropertyType.MESH];
+    propertyType = EXTENSION_NAME;
+    init() { }
+    get isValid() {
+        return this.maxSize !== undefined && this.maxSize > 0;
+    }
+    maxSize;
+    guid;
+}

package/dist/extensions/index.d.ts

@@ -3,4 +3,5 @@ export * from "./NEEDLE_mesh_compression/index.js";
 export * from "./NEEDLE_compression_texture/index.js";
 export * from "./NEEDLE_progressive/index.js";
 export * from "./NEEDLE_progressive_texture_settings/index.js";
+export * from "./NEEDLE_progressive_mesh_settings/index.js";
 export declare function registerExtensions(node: any): void;

package/dist/extensions/index.js

@@ -4,6 +4,7 @@ export * from "./NEEDLE_mesh_compression/index.js";
 export * from "./NEEDLE_compression_texture/index.js";
 export * from "./NEEDLE_progressive/index.js";
 export * from "./NEEDLE_progressive_texture_settings/index.js";
+export * from "./NEEDLE_progressive_mesh_settings/index.js";
 import { ALL_EXTENSIONS } from '@gltf-transform/extensions';
 import { ALL_EXTENSIONS as NEEDLE_EXTENSIONS } from "./NEEDLE_opaque/index.js";
 import { NEEDLE_progressive } from './NEEDLE_progressive/index.js';

package/dist/transforms/needle_mesh_transform.d.ts

@@ -1,3 +1,4 @@
-import { Transform } from "@gltf-transform/core";
-import { SimplifyOptions } from "@gltf-transform/functions";
+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;
+export declare function compressPrimitive(document: Document, mesh: Mesh, prim: Primitive, weldOptions: Required<WeldOptions>, meshOptions: Required<SimplifyOptions>): void;

package/dist/transforms/needle_mesh_transform.js

@@ -64,6 +64,7 @@ async function simplifierTransform(document, _context, _options) {
             const simplifyOpts = { ...options };
             if (!ext) {
                 // If no extension exists on the primitive dont apply any simplification
+                // console.log(`[${NAME}]: Skipping primitive simplification of mesh "${mesh.getName()}": No mesh compression extension found.`);
                 continue;
             }
             if (mesh_compression) {
@@ -87,7 +88,7 @@ async function simplifierTransform(document, _context, _options) {
     }
     return true;
 }
-function compressPrimitive(document, mesh, prim, weldOptions, meshOptions) {
+export function compressPrimitive(document, mesh, prim, weldOptions, meshOptions) {
     const logger = document.getLogger();
     logger.debug(`[${NAME}]: Welding primitive of mesh "${mesh.getName()}" → tolerance: ${weldOptions.tolerance}`);
     weldPrimitive(document, prim, weldOptions);

package/dist/transforms/needle_progressive.d.ts

@@ -31,4 +31,5 @@ export declare enum TextureResizeFilter {
 }
 export declare const TEXTURE_RESIZE_DEFAULTS: TextureResizeOptions;
 export declare function resizeTextureToMax(texture: Texture, maxSize: number, logger: ILogger): Promise<void>;
+export declare function make_progressive_meshes(filePath: string, _options: any, opts?: ProgressiveOptions): Transform;
 export {};

package/dist/transforms/needle_progressive.js

@@ -1,32 +1,40 @@
 import { BufferUtils, Document, NodeIO, PropertyType } from '@gltf-transform/core';
-import { listTextureSlots } from '@gltf-transform/functions';
-import { NEEDLE_PROGRESSIVE_TEXTURE_EXTENSION_NAME, NEEDLE_progressive, generateGuid } from "../extensions/NEEDLE_progressive/index.js";
-import { createOpaqueExtension, NEEDLE_compression_texture, NEEDLE_mesh_compression, NEEDLE_progressive_texture_settings, registerExtensions as registerDefaultExtensions } from '../extensions/index.js';
+import { SIMPLIFY_DEFAULTS, WELD_DEFAULTS, listTextureSlots } from '@gltf-transform/functions';
+import { NEEDLE_PROGRESSIVE_EXTENSION_NAME, NEEDLE_progressive, generateGuid } from "../extensions/NEEDLE_progressive/index.js";
+import { createOpaqueExtension, NEEDLE_compression_texture, NEEDLE_mesh_compression, NEEDLE_progressive_mesh_settings, NEEDLE_progressive_texture_settings, registerExtensions as registerDefaultExtensions } from '../extensions/index.js';
 import path from 'path';
 import { existsSync } from 'fs';
 import { addToCache, getKey, tryGetFromCache } from '../cache/index.js';
 import sharp from "sharp";
 import { foreachGLTF } from '../utils/index.js';
 import { needle_asset } from './needle_asset.js';
-import { MeshoptDecoder } from 'meshoptimizer';
+import { MeshoptDecoder, MeshoptSimplifier } from 'meshoptimizer';
+import { compressPrimitive } from './needle_mesh_transform.js';
+export async function make_progressive(opts) {
+    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
+        if (isMeshLOD(f) || isImageLOD(f)) {
+            console.log(`Progressive Transform: Ignore existing LOD file at ${f}`);
+            return;
+        }
+        await process(f, opts);
+    });
+}
 function registerExtensions(io) {
     registerDefaultExtensions(io);
     io.registerExtensions([
         NEEDLE_progressive,
         NEEDLE_progressive_texture_settings,
+        NEEDLE_progressive_mesh_settings,
+        NEEDLE_mesh_compression,
         //@ts-ignore
         createOpaqueExtension(NEEDLE_compression_texture.EXTENSION_NAME, PropertyType.TEXTURE),
         //@ts-ignore
-        createOpaqueExtension(NEEDLE_mesh_compression.EXTENSION_NAME, [PropertyType.ROOT, PropertyType.MESH, PropertyType.PRIMITIVE])
+        // createOpaqueExtension(NEEDLE_mesh_compression.EXTENSION_NAME, [PropertyType.ROOT, PropertyType.MESH, PropertyType.PRIMITIVE]),
     ]);
 }
-export async function make_progressive(opts) {
-    console.log("INFO: Run progressive transform: " + opts.path);
-    const file = opts.path;
-    return foreachGLTF(file, async (f) => {
-        await process(f, opts);
-    });
-}
 async function process(file, opts) {
     if (!file.endsWith(".glb") && !file.endsWith(".gltf")) {
         console.log("ERR: file is not gltf/glb");
@@ -59,7 +67,7 @@ async function process(file, opts) {
             }
             //@ts-ignore
             document.getLogger().verbosity = 0;
-            await document.transform(needle_asset(), make_progressive_textures(file, { size: [256, 256] }, opts));
+            await document.transform(needle_asset(), make_progressive_textures(file, { size: [256, 256] }, opts), make_progressive_meshes(file, {}, opts));
             let filename = file;
             if (opts.debug === true) {
                 // get extension
@@ -84,7 +92,7 @@ export function createTransform(name, fn) {
     Object.defineProperty(fn, 'name', { value: name });
     return fn;
 }
-const NAME = 'textureResize';
+const NAME = 'NEEDLE_progressive';
 export function make_progressive_textures(filePath, _options = TEXTURE_RESIZE_DEFAULTS, opts) {
     console.log("Make progressive: " + filePath);
     const startTime = Date.now();
@@ -124,7 +132,7 @@ export function make_progressive_textures(filePath, _options = TEXTURE_RESIZE_DE
             }
             options.size[0] = settings.maxSize;
             options.size[1] = settings.maxSize;
-            const existingExtension = texture.getExtension(NEEDLE_PROGRESSIVE_TEXTURE_EXTENSION_NAME);
+            const existingExtension = texture.getExtension(NEEDLE_PROGRESSIVE_EXTENSION_NAME);
             if (existingExtension !== undefined && existingExtension !== null) {
                 logger.debug(`${NAME}: Skipping, texture is already progressive ${textureIndex}`);
                 continue;
@@ -141,10 +149,9 @@ export function make_progressive_textures(filePath, _options = TEXTURE_RESIZE_DE
             }
             const relName = path.relative(directory, outPath);
             // TODO: this path should be added to the NEEDLE dependencies extension
-            texture.setExtension(NEEDLE_PROGRESSIVE_TEXTURE_EXTENSION_NAME, progressiveExt.create({
-                uri: relName,
+            texture.setExtension(NEEDLE_PROGRESSIVE_EXTENSION_NAME, progressiveExt.create({
                 guid: textureGuid,
-                level: 0,
+                uri: relName,
             }));
             const key = getKey(texture);
             if (opts.useCache) {
@@ -219,14 +226,16 @@ function createTextureLod(basePath, level, texture, slots, guid, textureIndex) {
     }
     // add progressive texture extension
     const progressiveExt = newDoc.createExtension(NEEDLE_progressive);
-    newTexture.setExtension(NEEDLE_PROGRESSIVE_TEXTURE_EXTENSION_NAME, progressiveExt.create({
+    newTexture.setExtension(NEEDLE_PROGRESSIVE_EXTENSION_NAME, progressiveExt.create({
         guid: guid,
     }));
     const newIo = new NodeIO();
     registerExtensions(newIo);
     const ext = ".glb";
     const imageName = "image_" + level + "_" + guid;
-    const outName = basePath + imageName + ext;
+    const filename = imageName + ext;
+    const outName = basePath + filename;
+    console.log(`INFO: Write texture LOD ${level} to \"${filename}\"`);
     newIo.write(outName, newDoc);
     return outName;
 }
@@ -280,3 +289,182 @@ async function resizeTexture(options, texture, logger, uri, slots) {
         .toBuffer();
     texture.setImage(BufferUtils.toView(buffer));
 }
+export function make_progressive_meshes(filePath, _options, opts) {
+    const directory = path.dirname(filePath);
+    // const fileNameWithoutExtension = path.basename(filePath, path.extname(filePath));
+    const outputDirectory = directory + "/";
+    return createTransform("PROGRESSIVE_MESHES", async (doc, _context) => {
+        if (isMeshLOD(filePath)) {
+            console.log("Progressive Mesh Transform: skip lod at " + filePath);
+            return Promise.resolve();
+        }
+        const logger = doc.getLogger();
+        const filename = path.basename(filePath);
+        console.log("> Progressive Mesh Transform: " + filename);
+        let index = 0;
+        // the lowest LOD (last entry) will be saved in the original file
+        const LODS = [
+            { error: 0 },
+            { ratio: 0.5, error: 1 },
+            { ratio: 0.25, error: 1 },
+        ];
+        /** Map of visited GUID -> extension */
+        const visited = new Map();
+        const meshes = doc.getRoot().listMeshes();
+        for (const mesh of meshes) {
+            // TODO: skip meshes that are already below a certain threshold (E.g. just 4 vertices)
+            const settings = mesh.getExtension(NEEDLE_progressive_mesh_settings.EXTENSION_NAME);
+            if (!settings) {
+                logger.debug(`${NAME}: no ${NEEDLE_progressive_mesh_settings.EXTENSION_NAME} found for mesh at index ${index++}`);
+                continue;
+            }
+            const progressiveExt = doc.createExtension(NEEDLE_progressive);
+            if (!progressiveExt || !progressiveExt.create) {
+                logger.debug(`${NAME}: Skipping because progressive extension is not available. ${index++}`);
+                continue;
+            }
+            // check if we have already produced LODs for this mesh
+            let needsToGenerateLODs = true;
+            const generatedLODs = new Array();
+            if (visited.has(settings.guid)) {
+                // we can not just set the extension here...
+                logger.debug(`${NAME}: Mesh has already been processed ${index} - will use previously generated LODs`);
+                needsToGenerateLODs = false;
+                const existingPaths = visited.get(settings.guid).paths;
+                generatedLODs.push(...existingPaths);
+            }
+            if (needsToGenerateLODs) {
+                // produce LODS, skip the last level because it will be saved in the original file
+                for (let level = 0; level < LODS.length - 1; level++) {
+                    const lod = LODS[level];
+                    console.log(`${NAME}: Generate LOD ${level}`);
+                    const guid = settings.guid;
+                    const lodPath = createMeshLod(doc, outputDirectory, level, mesh, guid, lod);
+                    generatedLODs.push(lodPath);
+                }
+            }
+            for (const prim of mesh.listPrimitives()) {
+                const lastLod = LODS[LODS.length - 1];
+                console.log(`${NAME}: ${filename} LOD ${LODS.length - 1}`);
+                simplifyMesh(doc, mesh, prim, lastLod);
+            }
+            const model = progressiveExt.create({
+                guid: settings.guid,
+                uri: generatedLODs.map(l => l),
+            });
+            mesh.setExtension(NEEDLE_PROGRESSIVE_EXTENSION_NAME, model);
+            index++;
+            if (!visited.has(settings.guid)) {
+                visited.set(settings.guid, {
+                    model: model,
+                    paths: generatedLODs,
+                });
+            }
+        }
+        console.log("< Progressive Mesh Transform: finished");
+    });
+}
+/**
+ * @param basePath the base path to save the lod files
+ * @param level: 0 = original, 1 = first lod, 2 = second lod, ...
+ * @param mesh the mesh
+ * @param guid a unique identifier for the mesh
+ * @param error the error to use for simplification. Higher means more simplification
+ */
+function createMeshLod(doc, basePath, level, mesh, guid, lodLevel) {
+    const newDoc = new Document();
+    const newScene = newDoc.createScene();
+    newDoc.createBuffer();
+    const newNode = newDoc.createNode();
+    newScene.addChild(newNode);
+    newNode.setName("node_" + level + "_" + guid);
+    newNode.setTranslation([0, 0, 0]);
+    const newMesh = newDoc.createMesh();
+    newNode.setMesh(newMesh);
+    const primitives = mesh.listPrimitives();
+    for (const prim of primitives) {
+        const newMat = newDoc.createMaterial();
+        const newPrim = newDoc.createPrimitive();
+        newMesh.addPrimitive(newPrim);
+        newPrim.setName(prim.getName());
+        newPrim.setMode(prim.getMode());
+        newPrim.setMaterial(newMat);
+        const semantics = prim.listSemantics();
+        for (let i = 0; i < semantics.length; i++) {
+            const attr = prim.getAttribute(semantics[i]);
+            if (attr) {
+                const newAttr = newDoc.createAccessor();
+                newAttr.setArray(attr.getArray());
+                newAttr.setType(attr.getType());
+                newPrim.setAttribute(semantics[i], newAttr);
+            }
+        }
+        const indices = prim.getIndices();
+        if (indices) {
+            const newIndices = newDoc.createAccessor();
+            newIndices.setArray(indices.getArray());
+            newIndices.setType(indices.getType());
+            newPrim.setIndices(newIndices);
+        }
+        const extensions = prim.listExtensions();
+        for (const ext of extensions) {
+            const PropertyClass = ext.constructor;
+            const newProp = new PropertyClass(newDoc.getGraph());
+            const copy = newProp.copy(ext);
+            const name = ext.extensionName;
+            console.log(`${NAME}: Copy primitive ${name} extension`);
+            newPrim.setExtension(name, copy);
+        }
+    }
+    if (lodLevel.error != undefined || lodLevel.ratio != undefined) {
+        for (const prim of newMesh.listPrimitives()) {
+            simplifyMesh(newDoc, newMesh, prim, lodLevel);
+        }
+    }
+    const progressiveExt = newDoc.createExtension(NEEDLE_progressive);
+    if (!progressiveExt || !progressiveExt.create) {
+        console.error("Failed to create progressive extension");
+        return;
+    }
+    newMesh.setExtension(NEEDLE_PROGRESSIVE_EXTENSION_NAME, progressiveExt.create({
+        guid: guid,
+    }));
+    // we need to compress the mesh with the same compression method as the original file
+    const root = doc.getRoot();
+    const compressionExt = root.getExtension(NEEDLE_mesh_compression.EXTENSION_NAME);
+    if (compressionExt) {
+        const newExt = newDoc.createExtension(NEEDLE_mesh_compression);
+        const newProp = newExt.create(compressionExt.model);
+        console.log(`${NAME}: Pass compression format to mesh LOD ${level} → ${JSON.stringify(compressionExt.model)}`);
+        newDoc.getRoot().setExtension(NEEDLE_mesh_compression.EXTENSION_NAME, newProp);
+    }
+    const newIo = new NodeIO();
+    registerExtensions(newIo);
+    const ext = ".glb";
+    const name = "mesh_lod_" + level + "_" + guid;
+    const filename = name + ext;
+    const outName = basePath + filename;
+    console.log(`${NAME}: Write mesh LOD ${level} to \"${filename}\" with: ${JSON.stringify(lodLevel)}`);
+    newIo.write(outName, newDoc);
+    return filename;
+}
+function simplifyMesh(doc, mesh, prim, lodinfo) {
+    const weldOptions = {
+        ...WELD_DEFAULTS,
+        overwrite: true,
+    };
+    const simplifyOptions = {
+        ...SIMPLIFY_DEFAULTS, simplifier: MeshoptSimplifier,
+    };
+    if (lodinfo.error != undefined)
+        simplifyOptions.error = lodinfo.error;
+    if (lodinfo.ratio != undefined)
+        simplifyOptions.ratio = lodinfo.ratio;
+    compressPrimitive(doc, mesh, prim, weldOptions, simplifyOptions);
+}
+function isMeshLOD(filepath) {
+    return filepath.includes("mesh_lod_");
+}
+function isImageLOD(filepath) {
+    return filepath.includes("image_");
+}

package/dist/utils/fileutils.js

@@ -62,7 +62,7 @@ async function testEntry(entry, callback, context) {
         // Try resolve potential relative path
         const newPath = context.baseDirectory + "/" + entry;
         if (existsSync(newPath) === false) {
-            console.log(`INFO: Resolved path failed: ${entry} -> ${newPath}`);
+            console.log(`INFO: Resolved path failed: ${entry} -> ${newPath} (doesnt exist or is locked by another process)`);
             return;
         }
         else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@needle-tools/gltf-build-pipeline",
-  "version": "1.3.1",
+  "version": "1.4.1-beta",
   "description": "Pipeline and tools for optimizing gltf files using gltf-transform and compression settings within glTF extensions",
   "main": "index.mjs",
   "type": "module",
@@ -16,9 +16,9 @@
     "compile": "tsc || exit 1"
   },
   "dependencies": {
-    "@gltf-transform/core": "^3.7.3",
-    "@gltf-transform/extensions": "^3.7.3",
-    "@gltf-transform/functions": "^3.7.3",
+    "@gltf-transform/core": "^3.10.0",
+    "@gltf-transform/extensions": "^3.10.0",
+    "@gltf-transform/functions": "^3.10.0",
     "command-exists": "^1.2.9",
     "command-line-args": "^5.2.1",
     "draco3dgltf": "^1.5.3",