@needle-tools/gltf-build-pipeline 1.4.1-beta.10 → 1.4.1-beta.11

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.11] - 2023-03-20
+- add: NEEDLE_progressive LOD meshes morph targets data
+- fix: NEEDLE_progressive should check if simplifcation did result in improved meshes (> 32 verts removed && > 5 % improvement) and otherwise discard LODs (and the whole extension if no improvement was made)
+- change: Unity NEEDLE_progressive logs
+
 ## [1.4.1-beta.10] - 2023-03-19
 - change: NEEDLE_progressive calculates density per mesh level
 - change: NEEDLE_progressive `uri` field is removed and added `lod` array of objects

package/dist/transforms/needle_mesh_transform.d.ts

@@ -1,4 +1,4 @@
 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, index: number, weldOptions: Required<WeldOptions>, meshOptions: Required<SimplifyOptions>): Promise<void>;
+export declare function compressPrimitive(document: Document, mesh: Mesh, prim: Primitive, index: number, weldOptions: Required<WeldOptions>, meshOptions: Required<SimplifyOptions>): Promise<Primitive>;

package/dist/transforms/needle_mesh_transform.js

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

package/dist/transforms/needle_progressive.js

@@ -306,7 +306,7 @@ export function make_progressive_meshes(filePath, _options, opts) {
         await MeshoptSimplifier.ready;
         const logger = doc.getLogger();
         const filename = path.basename(filePath);
-        console.log(`> [${NAME}] start generating LOD meshes for \"${filename}\"`);
+        console.log(`[${NAME}]: Begin generating progressive meshes for \"${filename}\"`);
         let index = 0;
         // the lowest LOD (last entry) will be saved in the original file
         const MAX_LODS = 6;
@@ -333,12 +333,13 @@ export function make_progressive_meshes(filePath, _options, opts) {
         const visited = new Map();
         const meshes = doc.getRoot().listMeshes();
         for (const mesh of meshes) {
-            const meshInformation = getMeshInformation(mesh);
-            const { totalVertexCount, maxVertexCount } = meshInformation;
+            /** The size and vertex count of the original mesh */
+            const originalMeshInformation = getMeshInformation(mesh);
+            const { totalVertexCount: originalTotalVertexCount, maxVertexCount: originalMaxVertexCount } = originalMeshInformation;
             let settings = mesh.getExtension(NEEDLE_progressive_mesh_settings.EXTENSION_NAME);
             if (!settings) {
-                if (maxVertexCount < 32) {
-                    logger.debug(`[${NAME}] Skipping, no settings found and no primitive with more than 32 vertices. mesh[${index}] has ${totalVertexCount} vertices (max: ${maxVertexCount})`);
+                if (originalMaxVertexCount < 32) {
+                    logger.debug(`[${NAME}] Skipping, no settings found and no primitive with more than 32 vertices. mesh[${index}] has ${originalTotalVertexCount} vertices (max: ${originalMaxVertexCount})`);
                     continue;
                 }
                 else {
@@ -346,7 +347,7 @@ export function make_progressive_meshes(filePath, _options, opts) {
                         guid: generateGuid(path + "_mesh_" + index.toString()),
                         generateLods: true,
                     };
-                    logger.debug(`[${NAME}] No settings found for mesh[${index}] with ${totalVertexCount} vertices (max: ${maxVertexCount}) - will use default settings (guid: ${settings.guid})`);
+                    logger.debug(`[${NAME}] No settings found for mesh[${index}] with ${originalTotalVertexCount} vertices (max: ${originalMaxVertexCount}) - will use default settings (guid: ${settings.guid})`);
                 }
             }
             else if (settings.generateLods === false) {
@@ -371,12 +372,13 @@ export function make_progressive_meshes(filePath, _options, opts) {
             /** async simplification tasks... */
             const tasks = new Array();
             if (needsToGenerateLODs) {
+                console.log(`[${NAME}] Begin generating mesh LODs for \"${mesh.getName()}\"`);
                 // 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];
                     const guid = settings.guid;
                     // TODO: check if the LOD level did actually change the mesh - otherwise we can just skip generating lower resolutions
-                    const lodTask = createMeshLod(doc, outputDirectory, level, mesh, meshInformation, guid, lod, opts);
+                    const lodTask = createMeshLod(doc, outputDirectory, level, mesh, originalMeshInformation, guid, lod, opts);
                     lodTask.then(res => {
                         if (res?.success) {
                             generatedLODInfos[level] = res;
@@ -406,11 +408,11 @@ export function make_progressive_meshes(filePath, _options, opts) {
                     let shouldOmitLevel = false;
                     // if the mesh size on disc is identical to the last level, we can omit this level
                     if (sizeOnDisc <= 0) {
-                        console.log(`[${NAME}] mesh LOD ${level} size on disc is 0 - level will be omitted (if this mesh is is taken from cache it can mean that the LOD level was omitted before) \"${lodInfo.path}\"`);
+                        console.log(`[${NAME}] Flag mesh LOD ${level}: size on disc is 0 → level will be omitted (if this mesh is is taken from cache it can mean that the LOD level was omitted before). \"${mesh.getName()}\" at \"${lodInfo.path}\"`);
                         shouldOmitLevel = true;
                     }
                     else if (diff == 0) {
-                        console.log(`[${NAME}] mesh LOD ${level} size on disc did not change compared to previous level - level will be omitted \"${lodInfo.path}\"`);
+                        console.log(`[${NAME}] Flag mesh LOD ${level}: size on disc did not change compared to previous level → level will be omitted. \"${mesh.getName()}\" at \"${lodInfo.path}\"`);
                         shouldOmitLevel = true;
                     }
                     else if (!shouldOmitLevel) {
@@ -419,13 +421,13 @@ export function make_progressive_meshes(filePath, _options, opts) {
                         const lastMeshInfo = generatedLODInfos[i - 1]?.lodMeshInfo;
                         if (meshInfo && lastMeshInfo) {
                             const vertexDifference = lastMeshInfo.totalVertexCount - meshInfo.totalVertexCount;
-                            const diffPercent = vertexDifference / lastMeshInfo.totalVertexCount;
+                            const diff01 = vertexDifference / lastMeshInfo.totalVertexCount;
                             if (vertexDifference < 0) {
-                                console.log(`WARN: [${NAME}] mesh LOD ${level} did increase vertex count (${-vertexDifference.toFixed(0)} vertices, ${(-diffPercent * 100).toFixed(4)}%) - level will be omitted \"${lodInfo.path}\" ${JSON.stringify(lastMeshInfo)} → ${JSON.stringify(meshInfo)}`);
+                                console.log(`WARN: ❌ [${NAME}] Flag mesh LOD ${level}: vertex count did increase (${-vertexDifference.toFixed(0)} vertices, ${(-diff01 * 100).toFixed(4)}%) → LOD ${level} will be omitted. \"${mesh.getName()}\" at \"${lodInfo.path}\" ${JSON.stringify(lastMeshInfo)} → ${JSON.stringify(meshInfo)}`);
                                 shouldOmitLevel = true;
                             }
-                            else if (vertexDifference < 32 || diffPercent < 0.05) {
-                                console.log(`[${NAME}] mesh LOD ${level} change was too low (${-vertexDifference.toFixed(0)} vertices, ${(-diffPercent * 100).toFixed(4)}%) - level will be omitted \"${lodInfo.path}\" ${JSON.stringify(lastMeshInfo)} → ${JSON.stringify(meshInfo)}`);
+                            else if (vertexDifference < 32 || diff01 < 0.05) {
+                                console.log(`[${NAME}] Flag mesh LOD ${level}: vertex count difference below threshold (removed ${vertexDifference.toFixed(0)} vertices, ${(-diff01 * 100).toFixed(4)}%) → LOD ${level} will be omitted. \"${mesh.getName()}\" at \"${lodInfo.path}\"`);
                                 shouldOmitLevel = true;
                             }
                         }
@@ -446,10 +448,9 @@ export function make_progressive_meshes(filePath, _options, opts) {
             }
             let maxDensity = 0;
             let primitiveIndex = 0;
+            const lodLevelInFile = generatedLODInfos.length;
             for (const prim of mesh.listPrimitives()) {
-                const lodsCount = generatedLODInfos.length;
-                const lastLod = LODS[lodsCount];
-                console.log(`[${NAME}] ${mesh.getName()} LOD ${lodsCount}`);
+                const lastLod = LODS[lodLevelInFile];
                 // TODO: this should be run after simplification but then we need to change the runtime to use the LOD 0 density
                 const density = calculateMeshDensity(prim);
                 maxDensity = Math.max(maxDensity, density);
@@ -459,8 +460,23 @@ export function make_progressive_meshes(filePath, _options, opts) {
             await Promise.all(tasks);
             tasks.length = 0;
             const { totalVertexCount: totalVertexCountAfter } = getMeshInformation(mesh);
+            const difference = originalTotalVertexCount - totalVertexCountAfter;
+            const diff01 = difference / originalTotalVertexCount;
             if (totalVertexCountAfter <= 0) {
-                logger.error(`ERR: [${NAME}] Mesh[${index}] has no vertices after simplification: ${mesh.getName()}`);
+                logger.error(`ERR: [${NAME}]: Mesh[${index}] has no vertices after simplification: ${mesh.getName()}`);
+            }
+            else if (difference < 32 || diff01 <= 0.05) {
+                // the lowest LOD has the same vertex count as the original mesh → we don't need to write the extension and can also delete previously generated LODs
+                console.log(`[${NAME}]: Flag mesh LOD ${generatedLODInfos.length}: vertex count difference below threshold (removed ${difference} vertices, ${(-diff01 * 100).toFixed(2)} %) → will remove LODs. \"${mesh.getName()}\"`);
+                try {
+                    for (const lodInfo of generatedLODInfos) {
+                        rmSync(outputDirectory + "/" + lodInfo.path);
+                    }
+                }
+                catch (err) {
+                    logger.error(`ERR: [${NAME}] Failed to remove LOD files for \"${mesh.getName()}\"`);
+                }
+                continue;
             }
             if (generatedLODInfos.length > 0) {
                 const model = progressiveExt.create({
@@ -483,7 +499,7 @@ export function make_progressive_meshes(filePath, _options, opts) {
                 }
             }
         }
-        console.log(`< [${NAME}] finished generating LOD meshes for \"${filename}\"`);
+        console.log(`[${NAME}]: Finished generating progressive meshes for \"${filename}\"`);
     });
 }
 /**
@@ -527,6 +543,10 @@ async function createMeshLod(doc, basePath, level, mesh, meshInfo, guid, lodLeve
     newMesh.setName(mesh.getName() + " LOD " + level);
     newNode.setMesh(newMesh);
     const newMat = newDoc.createMaterial();
+    const weights = mesh.getWeights();
+    if (weights) {
+        newMesh.setWeights(weights);
+    }
     const tasks = new Array();
     // let didRunSimplification = false;
     for (const prim of primitives) {
@@ -544,6 +564,9 @@ async function createMeshLod(doc, basePath, level, mesh, meshInfo, guid, lodLeve
                 newAttr.setType(attr.getType());
                 newPrim.setAttribute(semantics[i], newAttr);
             }
+            else {
+                console.warn(`[${NAME}] Missing attribute ${semantics[i]} in mesh LOD ${level}`);
+            }
         }
         const indices = prim.getIndices();
         if (indices) {
@@ -552,6 +575,21 @@ async function createMeshLod(doc, basePath, level, mesh, meshInfo, guid, lodLeve
             newIndices.setType(indices.getType());
             newPrim.setIndices(newIndices);
         }
+        const targets = prim.listTargets();
+        for (const target of targets) {
+            const newTarget = newDoc.createPrimitiveTarget(target.getName());
+            newPrim.addTarget(newTarget);
+            for (const attr of target.listSemantics()) {
+                const accessor = target.getAttribute(attr);
+                if (accessor) {
+                    const newAccessor = newDoc.createAccessor();
+                    newAccessor.setArray(accessor.getArray());
+                    newAccessor.setType(accessor.getType());
+                    newTarget.setAttribute(attr, newAccessor);
+                }
+            }
+        }
+        ;
         const extensions = prim.listExtensions();
         for (const ext of extensions) {
             const PropertyClass = ext.constructor;
@@ -603,7 +641,7 @@ async function createMeshLod(doc, basePath, level, mesh, meshInfo, guid, lodLeve
     }
     const newIo = new NodeIO();
     registerExtensions(newIo);
-    console.log(`[${NAME}] Write mesh LOD ${level} with: ${JSON.stringify(lodLevel)} to \"${fileName}\"`);
+    console.log(`[${NAME}] Write mesh LOD ${level} with to \"${fileName}\"`);
     await newIo.write(outPath, newDoc);
     // const hasChanged = meshInfo.maxVertexCount == newMeshInformation.maxVertexCount && meshInfo.totalVertexCount == newMeshInformation.totalVertexCount;
     // add to cache

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@needle-tools/gltf-build-pipeline",
-  "version": "1.4.1-beta.10",
+  "version": "1.4.1-beta.11",
   "description": "Pipeline and tools for optimizing gltf files using gltf-transform and compression settings within glTF extensions",
   "main": "index.mjs",
   "type": "module",