@needle-tools/gltf-build-pipeline 1.4.0-beta → 1.4.1-beta.1

package/CHANGELOG.md

@@ -4,6 +4,11 @@ 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)
 

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

@@ -1,8 +1,8 @@
 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;
+    uri?: string | Array<string>;
 }
 export declare function generateGuid(): string;
 export declare class NEEDLE_progressive extends Extension {

package/dist/extensions/NEEDLE_progressive_mesh_settings/index.js

@@ -9,31 +9,16 @@ export class NEEDLE_progressive_mesh_settings extends Extension {
             return this;
         const root = this.document.getRoot();
         const meshes = root.listMeshes();
-        /**
-         * If a mesh is used in multiple objects it only appears once in the gltf-transform list
-         * So we have to store the key and the index of the mesh in the list
-         */
-        const map = new Map();
-        let offset = 0;
         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 - offset;
-                const key = ext.guid;
-                if (map.has(key)) {
-                    offset += 1;
-                    console.log(`INFO: Progressive mesh extension was ${i} already found...`);
-                    continue;
-                }
-                else {
-                    map.set(key, index);
-                }
-                const tex = meshes[index];
-                if (tex)
-                    tex.setExtension(EXTENSION_NAME, prop);
+                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}\"`);
                 }

package/dist/transforms/needle_progressive.js

@@ -150,8 +150,8 @@ 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_EXTENSION_NAME, progressiveExt.create({
-                uri: relName,
                 guid: textureGuid,
+                uri: relName,
             }));
             const key = getKey(texture);
             if (opts.useCache) {
@@ -300,51 +300,68 @@ export function make_progressive_meshes(filePath, _options, opts) {
         }
         const logger = doc.getLogger();
         const filename = path.basename(filePath);
-        console.log("Progressive Mesh Transform: " + filename);
+        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 },
-            // { error: 0.05 },
-            { error: 0.15 },
+            { ratio: 0.5, error: 1 },
+            { ratio: 0.25, error: 1 },
         ];
-        for (const mesh of doc.getRoot().listMeshes()) {
+        /** 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}`);
+                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}`);
+                logger.debug(`${NAME}: Skipping because progressive extension is not available. ${index++}`);
                 continue;
             }
-            const lod_infos = new Array();
-            // 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}: ${filename} LOD ${level} error: ${lod.error}`);
-                const guid = settings.guid;
-                const lodPath = createMeshLod(doc, outputDirectory, level, mesh, guid, lod.error);
-                lod_infos.push({
-                    path: lodPath,
-                    guid: guid,
-                });
+            // 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];
-                simplifyMesh(doc, mesh, prim, lastLod.error);
+                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++;
-            // TODO: need proper lod scheme, for now we use the same as for textures
-            const lodlevel = 0;
-            const lod0 = lod_infos[lodlevel];
-            mesh.setExtension(NEEDLE_PROGRESSIVE_EXTENSION_NAME, progressiveExt.create({
-                uri: lod0.path,
-                guid: lod0.guid,
-            }));
+            if (!visited.has(settings.guid)) {
+                visited.set(settings.guid, {
+                    model: model,
+                    paths: generatedLODs,
+                });
+            }
         }
+        console.log("< Progressive Mesh Transform: finished");
     });
 }
 /**
@@ -354,7 +371,7 @@ export function make_progressive_meshes(filePath, _options, opts) {
  * @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, error) {
+function createMeshLod(doc, basePath, level, mesh, guid, lodLevel) {
     const newDoc = new Document();
     const newScene = newDoc.createScene();
     newDoc.createBuffer();
@@ -399,9 +416,9 @@ function createMeshLod(doc, basePath, level, mesh, guid, error) {
             newPrim.setExtension(name, copy);
         }
     }
-    if (error > 0) {
+    if (lodLevel.error != undefined || lodLevel.ratio != undefined) {
         for (const prim of newMesh.listPrimitives()) {
-            simplifyMesh(newDoc, newMesh, prim, error);
+            simplifyMesh(newDoc, newMesh, prim, lodLevel);
         }
     }
     const progressiveExt = newDoc.createExtension(NEEDLE_progressive);
@@ -427,11 +444,11 @@ function createMeshLod(doc, basePath, level, mesh, guid, error) {
     const name = "mesh_lod_" + level + "_" + guid;
     const filename = name + ext;
     const outName = basePath + filename;
-    console.log(`${NAME}: Write mesh LOD ${level} to \"${filename}\" with error: ${error}`);
+    console.log(`${NAME}: Write mesh LOD ${level} to \"${filename}\" with: ${JSON.stringify(lodLevel)}`);
     newIo.write(outName, newDoc);
     return filename;
 }
-function simplifyMesh(doc, mesh, prim, error) {
+function simplifyMesh(doc, mesh, prim, lodinfo) {
     const weldOptions = {
         ...WELD_DEFAULTS,
         overwrite: true,
@@ -439,8 +456,10 @@ function simplifyMesh(doc, mesh, prim, error) {
     const simplifyOptions = {
         ...SIMPLIFY_DEFAULTS, simplifier: MeshoptSimplifier,
     };
-    if (error != undefined)
-        simplifyOptions.error = error;
+    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) {

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.4.0-beta",
+  "version": "1.4.1-beta.1",
   "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",