@needle-tools/gltf-build-pipeline 2.10.2-next.efa41cf → 2.11.0-beta

package/CHANGELOG.md

@@ -4,6 +4,10 @@ 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).
 
+## [2.11.0] - 2025-08-01
+- add: store densities per primitive
+- fix: exception during cache key calculation
+
 ## [2.10.2] - 2025-07-17
 - fix: issue where draco compression fails with `[KHR_draco_mesh_compression] Accessor cannot be shared by compressed and uncompressed primitives`
 

package/dist/cache/cache.js

@@ -252,7 +252,7 @@ function getCacheDirectory(root) {
     }
     return tmpDir;
 }
-function hashObject(obj) {
+function hashObject(obj, depth = 0) {
     if (obj instanceof Accessor) {
         const buffer = obj.getArray();
         return hashBuffer(buffer.buffer);
@@ -260,14 +260,42 @@ function hashObject(obj) {
     else if (obj == null) {
         return 0;
     }
+    if (typeof obj !== 'object') {
+        return hashString(String(obj));
+    }
     try {
         const str = JSON.stringify(obj);
         return hashString(str);
     }
     catch (err) {
-        console.error(err);
-        debugger;
-        throw err;
+        console.warn("WARN: [Cache] error during hashing of object:\n" + err);
+        if (debugLogs)
+            debugger;
+        // Fallback to a simple hash of the keys and values
+        // TODO: maybe we want to exclude this object now from the cache if it fails to serialize?
+        let fallbackHashj = 0;
+        if (typeof obj === 'object') {
+            if (obj === null)
+                return 0;
+            for (const key in obj) {
+                if (Object.prototype.hasOwnProperty.call(obj, key)) {
+                    const value = obj[key];
+                    fallbackHashj += hashString(key);
+                    if (typeof value === 'object') {
+                        if (depth > 10) {
+                            fallbackHashj += hashString("[object]");
+                        }
+                        else {
+                            fallbackHashj += hashObject(value, depth + 1);
+                        }
+                    }
+                    else {
+                        fallbackHashj += hashString(String(value));
+                    }
+                }
+            }
+        }
+        return fallbackHashj;
     }
 }
 function hashBuffer(buffer, offset, length) {

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

@@ -20,13 +20,13 @@ export type ProgressiveTextureModel = ProgressiveLoadingInfo & {
     lods?: Array<ProgressiveTextureLodEntry>;
 };
 export type ProgressiveMeshModel = ProgressiveLoadingInfo & {
-    /** LOD0 vertex density. TODO: remove this since we now have a LODs array. This is just for supporting older engine versions */
-    density: number;
     lods?: Array<LodInfo & {
-        /** Mesh vertex density */
+        /** @deprecated Mesh vertex density TODO: remove in the future */
         density: number;
         vertexCount: number;
         indexCount: number;
+        /** Densities per primitive */
+        densities?: Array<number>;
     }>;
 };
 export declare class NEEDLE_progressive extends Extension {

package/dist/transforms/needle_mesh_transform.js

@@ -194,6 +194,7 @@ export async function compressPrimitive(document, mesh, prim, index, weldOptions
         if (!res)
             return;
     }
+    // TODO: enable regularize once it's available: https://github.com/zeux/meshoptimizer/pull/914/files
     logger.debug(`simplify: primitive[${index}] of mesh "${mesh.getName()}" → ratio: ${meshOptions.ratio}, error: ${meshOptions.error}, lockBorder: ${meshOptions.lockBorder}`);
     return simplifyPrimitive(prim, meshOptions);
 }

package/dist/transforms/needle_progressive.js

@@ -546,10 +546,10 @@ export function make_progressive_meshes(filePath, _options, opts) {
             },
         ];
         for (let l = 0; l < MAX_LODS; l++) {
-            // const t = l / MAX_LODS;
+            const t = l / (MAX_LODS - 1);
             const latest = LODS[LODS.length - 1];
             const ratio = latest.ratio * .5;
-            let error = Math.min(.013 * (l + 1), 0.003);
+            let error = 0.003 + t * .01; // using max 1%, example mesh: https://linear.app/needle/issue/NE-6653
             if (opts.config.usecase === "product") {
                 error *= .5;
             }
@@ -688,7 +688,8 @@ export function make_progressive_meshes(filePath, _options, opts) {
             let primitiveIndex = 0;
             const lodLevelInFile = generatedLODInfos.length;
             const clonedData = { primitives: [], weights: [...mesh.getWeights()] };
-            for (const prim of mesh.listPrimitives()) {
+            // const primitiveDensities = new Array<number>(mesh.listPrimitives().length);
+            mesh.listPrimitives().forEach((prim, index) => {
                 const data = clonePrimitiveData(prim, logger);
                 if (data != null) {
                     clonedData.primitives.push(data);
@@ -697,10 +698,11 @@ export function make_progressive_meshes(filePath, _options, opts) {
                 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);
+                // primitiveDensities[index] = density;
                 maxDensity = Math.max(maxDensity, density);
                 const task = simplifyMesh(doc, mesh, prim, primitiveIndex++, lastLod);
                 tasks.push(task);
-            }
+            });
             await Promise.all(tasks);
             tasks.length = 0;
             const { totalVertexCount: totalVertexCountAfter } = getMeshInformation(mesh);
@@ -741,11 +743,11 @@ export function make_progressive_meshes(filePath, _options, opts) {
                             path: l.path,
                             hash: l.content_hash.toString(),
                             density: l.density,
+                            densities: l.densities,
                             vertexCount: l.lodMeshInfo?.totalVertexCount,
                             indexCount: l.lodMeshInfo?.totalIndexCount,
                         };
                     }),
-                    density: maxDensity,
                 });
                 mesh.setExtension(NEEDLE_PROGRESSIVE_EXTENSION_NAME, model);
                 index++;
@@ -825,7 +827,16 @@ async function createMeshLod(inputFileName, doc, basePath, level, mesh, meshInfo
         if (cachedValue && meta) {
             logger.info(`[${NAME}] LOD ${level} loaded from cache for \"${mesh.getName()}\"`);
             writeFileSync(outPath, cachedValue);
-            return { level, path: fileName, success: true, cacheKey, content_hash: hash, lodMeshInfo: meta.meshInfo, density: meta.density };
+            return {
+                level,
+                path: fileName,
+                success: true,
+                cacheKey,
+                content_hash: hash,
+                lodMeshInfo: meta.meshInfo,
+                density: meta.density,
+                densities: meta.densities
+            };
         }
     }
     const newDoc = new Document();
@@ -939,13 +950,24 @@ async function createMeshLod(inputFileName, doc, basePath, level, mesh, meshInfo
     const newMeshInformation = getMeshInformation(newMesh);
     if (newMeshInformation.totalVertexCount < 4) {
         logger.error(`[${NAME}] mesh LOD ${level} is has less than 4 vertices → skipping`);
-        return { level, path: fileName, success: false, cacheKey: cacheKey, content_hash: hash, lodMeshInfo: null, density: null, };
+        return {
+            level,
+            path: fileName,
+            success: false,
+            cacheKey: cacheKey,
+            content_hash: hash,
+            lodMeshInfo: null,
+            density: null,
+            densities: null
+        };
     }
     let density = 0;
-    for (const prim of newMesh.listPrimitives()) {
+    const densities = new Array(newMesh.listPrimitives().length);
+    newMesh.listPrimitives().forEach((prim, index) => {
         const d = calculateMeshDensity(prim);
         density = Math.max(density, d);
-    }
+        densities[index] = d;
+    });
     const progressiveExt = newDoc.createExtension(NEEDLE_progressive);
     if (!progressiveExt || !progressiveExt.createMesh) {
         logger.error("Failed to create progressive extension");
@@ -953,7 +975,6 @@ async function createMeshLod(inputFileName, doc, basePath, level, mesh, meshInfo
     }
     newMesh.setExtension(NEEDLE_PROGRESSIVE_EXTENSION_NAME, progressiveExt.createMesh({
         guid: guid,
-        density: density,
     }));
     // we need to compress the mesh with the same compression method as the original file
     const model = determineMeshCompression(doc, fileName);
@@ -977,7 +998,16 @@ async function createMeshLod(inputFileName, doc, basePath, level, mesh, meshInfo
         addToCache(cacheKey, bytes);
         addMetaToCache(cacheKey, { meshInfo: newMeshInformation, density: density });
     }
-    return { level, path: fileName, success: true, lodMeshInfo: newMeshInformation, cacheKey: cacheKey, content_hash: hash, density: density };
+    return {
+        level,
+        path: fileName,
+        success: true,
+        lodMeshInfo: newMeshInformation,
+        cacheKey: cacheKey,
+        content_hash: hash,
+        density: density,
+        densities: densities
+    };
 }
 async function simplifyMesh(doc, mesh, prim, index, lodinfo) {
     const weldOptions = {

package/dist/utils/version.gen.d.ts

@@ -1 +1 @@
-export declare const version = "2.10.2-next.efa41cf";
+export declare const version = "2.11.0-beta";

package/dist/utils/version.gen.js

@@ -1 +1 @@
-export const version = "2.10.2-next.efa41cf";
+export const version = "2.11.0-beta";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@needle-tools/gltf-build-pipeline",
-  "version": "2.10.2-next.efa41cf",
+  "version": "2.11.0-beta",
   "description": "Pipeline and tools for optimizing gltf files using gltf-transform and compression settings within glTF extensions",
   "main": "dist/index.js",
   "type": "module",
@@ -48,14 +48,14 @@
   },
   "dependencies": {
     "@donmccurdy/caporal": "~0.0.10",
-    "@gltf-transform/core": "4.1.4",
-    "@gltf-transform/extensions": "4.1.4",
-    "@gltf-transform/functions": "4.1.4",
+    "@gltf-transform/core": "4.2.1",
+    "@gltf-transform/extensions": "4.2.1",
+    "@gltf-transform/functions": "4.2.1",
     "command-exists": "^1.2.9",
     "command-line-args": "^5.2.1",
     "draco3dgltf": "^1.5.3",
     "glob": "^7.2.0",
-    "meshoptimizer": "^0.18.1",
+    "meshoptimizer": "0.24.0",
     "micromatch": "^4.0.5",
     "ndarray": "^1.0.19",
     "ndarray-lanczos": "^0.3.0",