@needle-tools/gltf-build-pipeline 1.4.1-beta.7 → 1.4.1-beta.9

package/CHANGELOG.md

@@ -4,6 +4,12 @@ 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.8] - 2023-03-18
+- change: if an asset doesnt have a guid we use a uuid package now
+- change: ignore mesh LODs with vertex count < 4
+- change: allow generating mesh LODs without extension (if the mesh has > 32 vertices)
+- change: omit generated LODs if the change is too small (e.g. the vertex count didnt change enough)
+
 ## [1.4.1-beta.6] - 2023-03-15
 - add: caching support for mesh LODs
 

package/dist/extensions/NEEDLE_mesh_compression/NEEDLE_mesh_compression.js

@@ -44,6 +44,8 @@ export class NEEDLE_mesh_compression extends Extension {
         return this;
     }
     write(ctx) {
+        if (debugLog)
+            console.log("WRITE " + EXTENSION_NAME);
         const root = this.document.getRoot();
         const rootExtension = root.getExtension(EXTENSION_NAME);
         if (rootExtension) {
@@ -72,7 +74,7 @@ export class NEEDLE_mesh_compression extends Extension {
 export class NEEDLE_mesh_compression_property extends ExtensionProperty {
     static EXTENSION_NAME = EXTENSION_NAME;
     extensionName = EXTENSION_NAME;
-    parentTypes = [PropertyType.PRIMITIVE, PropertyType.ROOT];
+    parentTypes = [PropertyType.ROOT, PropertyType.PRIMITIVE, PropertyType.MESH];
     propertyType = EXTENSION_NAME;
     init() { }
     model;

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

@@ -7,7 +7,6 @@ export declare interface IProgressiveLoadingInfo {
     uri?: string | Array<string>;
     density?: number;
 }
-export declare function generateGuid(): string;
 export declare class NEEDLE_progressive extends Extension {
     static EXTENSION_NAME: string;
     extensionName: string;

package/dist/extensions/NEEDLE_progressive/NEEDLE_progressive.js

@@ -1,10 +1,6 @@
-import { Extension, ExtensionProperty, PropertyType, uuid } from "@gltf-transform/core";
+import { Extension, ExtensionProperty, PropertyType } from "@gltf-transform/core";
 // TODO: rename to NEEDLE_progressive_texture
 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_EXTENSION_NAME;
     extensionName = NEEDLE_PROGRESSIVE_EXTENSION_NAME;

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

@@ -1,6 +1,7 @@
 import { Extension, ExtensionProperty, PropertyType, ReaderContext, WriterContext } from "@gltf-transform/core";
 export declare interface IProgressiveMeshSettings {
     guid: string;
+    generateLods: boolean;
 }
 export declare class NEEDLE_progressive_mesh_settings extends Extension {
     static EXTENSION_NAME: string;
@@ -14,7 +15,6 @@ export declare class NEEDLE_progressive_mesh_settings_property extends Extension
     parentTypes: PropertyType[];
     propertyType: string;
     init(): void;
-    get isValid(): boolean;
-    maxSize: number;
+    generateLods: boolean;
     guid: string;
 }

package/dist/extensions/NEEDLE_progressive_mesh_settings/index.js

@@ -36,9 +36,6 @@ export class NEEDLE_progressive_mesh_settings_property extends ExtensionProperty
     parentTypes = [PropertyType.MESH];
     propertyType = EXTENSION_NAME;
     init() { }
-    get isValid() {
-        return this.maxSize !== undefined && this.maxSize > 0;
-    }
-    maxSize;
+    generateLods;
     guid;
 }

package/dist/transforms/needle_progressive.js

@@ -1,15 +1,16 @@
 import { BufferUtils, Document, NodeIO, PropertyType } from '@gltf-transform/core';
 import { SIMPLIFY_DEFAULTS, WELD_DEFAULTS, listTextureSlots, sparse } from '@gltf-transform/functions';
-import { NEEDLE_PROGRESSIVE_EXTENSION_NAME, NEEDLE_progressive, generateGuid } from "../extensions/NEEDLE_progressive/index.js";
+import { NEEDLE_PROGRESSIVE_EXTENSION_NAME, NEEDLE_progressive } 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, readFileSync, rmSync, statSync, writeFileSync } from 'fs';
 import { addToCache, getHash, getKey, tryGetFromCache } from '../cache/index.js';
 import sharp from "sharp";
-import { foreachGLTF } from '../utils/index.js';
+import { foreachGLTF, generateGuid } from '../utils/index.js';
 import { needle_asset } 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);
     const file = opts.path;
@@ -109,40 +110,40 @@ export function make_progressive_textures(filePath, _options = TEXTURE_RESIZE_DE
             const uri = texture.getURI();
             const match = !options.pattern || options.pattern.test(name) || options.pattern.test(uri);
             if (!match) {
-                logger.debug(`${NAME}: Skipping, excluded by "pattern" parameter. ${textureIndex}`);
+                logger.debug(`[${NAME}] Skipping, excluded by "pattern" parameter. ${textureIndex}`);
                 continue;
             }
             if (texture.getMimeType() !== 'image/png' && texture.getMimeType() !== 'image/jpeg') {
-                logger.warn(`${NAME}: Skipping, unsupported texture type "${texture.getMimeType()} at ${textureIndex}".`);
+                logger.warn(`[${NAME}] Skipping, unsupported texture type "${texture.getMimeType()} at ${textureIndex}".`);
                 continue;
             }
             const slots = listTextureSlots(texture);
             if (options.slots && !slots.some((slot) => options.slots?.test(slot))) {
-                logger.debug(`${NAME}: Skipping, [${slots.join(', ')}] excluded by "slots" parameter. ${textureIndex}`);
+                logger.debug(`[${NAME}] Skipping, [${slots.join(', ')}] excluded by "slots" parameter. ${textureIndex}`);
                 continue;
             }
             const settings = texture.getExtension(NEEDLE_progressive_texture_settings.EXTENSION_NAME);
             if (!settings) {
-                logger.warn(`${NAME}: Skipping, no settings found ${textureIndex}`);
+                logger.warn(`[${NAME}] Skipping, no settings found ${textureIndex}`);
                 continue;
             }
             if (!settings.isValid) {
-                logger.warn(`${NAME}: Skipping, settings are invalid ${textureIndex}`);
+                logger.warn(`[${NAME}] Skipping, settings are invalid ${textureIndex}`);
                 continue;
             }
             options.size[0] = settings.maxSize;
             options.size[1] = settings.maxSize;
             const existingExtension = texture.getExtension(NEEDLE_PROGRESSIVE_EXTENSION_NAME);
             if (existingExtension !== undefined && existingExtension !== null) {
-                logger.debug(`${NAME}: Skipping, texture is already progressive ${textureIndex}`);
+                logger.debug(`[${NAME}] Skipping, texture is already progressive ${textureIndex}`);
                 continue;
             }
             const progressiveExt = doc.createExtension(NEEDLE_progressive);
             if (!progressiveExt || !progressiveExt.create) {
-                logger.debug(`${NAME}: Skipping because progressive extension is not available. ${textureIndex}`);
+                logger.debug(`[${NAME}] Skipping because progressive extension is not available. ${textureIndex}`);
                 continue;
             }
-            const textureGuid = settings.guid?.length ? settings.guid : generateGuid();
+            const textureGuid = settings.guid?.length ? settings.guid : generateGuid(path + "_texture_" + index.toString());
             const outPath = createTextureLod(textureLodBasePath, 0, texture, slots, textureGuid, textureIndex);
             if (!outPath) {
                 continue;
@@ -262,7 +263,7 @@ async function resizeTexture(options, texture, logger, uri, slots) {
     const [maxWidth, maxHeight] = options.size;
     const [srcWidth, srcHeight] = texture.getSize();
     if (srcWidth <= maxWidth && srcHeight <= maxHeight) {
-        logger.debug(`${NAME}: Skipping, the texture is already smaller than the requested size ${maxWidth}x${maxHeight}}`);
+        logger.debug(`[${NAME}] Skipping, the texture is already smaller than the requested size ${maxWidth}x${maxHeight}}`);
         return;
     }
     if (maxWidth <= 0 || maxHeight <= 0) {
@@ -298,6 +299,7 @@ export function make_progressive_meshes(filePath, _options, opts) {
             console.log("Progressive Mesh Transform: skip lod at " + filePath);
             return Promise.resolve();
         }
+        await MeshoptSimplifier.ready;
         const logger = doc.getLogger();
         const filename = path.basename(filePath);
         console.log("> Progressive Mesh Transform: " + filename);
@@ -326,28 +328,41 @@ export function make_progressive_meshes(filePath, _options, opts) {
         /** Map of visited GUID -> extension */
         const visited = new Map();
         const meshes = doc.getRoot().listMeshes();
-        await MeshoptSimplifier.ready;
         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);
+            const meshInformation = getMeshInformation(mesh);
+            const { totalVertexCount, maxVertexCount } = meshInformation;
+            let 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++}`);
+                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})`);
+                    continue;
+                }
+                else {
+                    settings = {
+                        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})`);
+                }
+            }
+            else if (settings.generateLods === false) {
+                logger.debug(`[${NAME}] progressive mesh disabled 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;
             }
             // check if we have already produced LODs for this mesh
             let needsToGenerateLODs = true;
-            const generatedLODs = new Array();
+            const generatedLODInfos = 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`);
+                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);
+                const existingPaths = visited.get(settings.guid);
+                generatedLODInfos.push(...existingPaths.infos);
             }
             /** async simplification tasks... */
             const tasks = new Array();
@@ -357,10 +372,10 @@ export function make_progressive_meshes(filePath, _options, opts) {
                     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, guid, lod, opts);
+                    const lodTask = createMeshLod(doc, outputDirectory, level, mesh, meshInformation, guid, lod, opts);
                     lodTask.then(res => {
                         if (res?.success) {
-                            generatedLODs[level] = res.path;
+                            generatedLODInfos[level] = res;
                         }
                     });
                     tasks.push(lodTask);
@@ -370,32 +385,66 @@ export function make_progressive_meshes(filePath, _options, opts) {
                 tasks.length = 0;
             }
             // compare LOD results and ignore if the mesh did not change
-            let prevSize = -1;
-            for (let i = 1; i < generatedLODs.length; i++) {
-                const path = generatedLODs[i];
-                if (!path) {
-                    console.log(`${NAME}: LOD ${i} was not generated for ${mesh.getName()}`);
+            // TODO: this should actually check mesh semantics (perhaps hash the mesh using the caching system?)
+            let prevSize = -Infinity;
+            for (let i = 0; i < generatedLODInfos.length; i++) {
+                const lodInfo = generatedLODInfos[i];
+                if (!lodInfo) {
+                    console.log(`[${NAME}] LOD ${i} doesnt exist`);
                     continue;
                 }
-                const fullPath = outputDirectory + path;
+                const fullPath = outputDirectory + lodInfo.path;
                 if (existsSync(fullPath)) {
                     const lastSize = prevSize;
                     const sizeOnDisc = statSync(fullPath).size;
-                    prevSize = sizeOnDisc;
                     const diff = lastSize - sizeOnDisc;
-                    if (diff < 100) {
-                        console.log(`${NAME}: LOD ${i} did not change for ${mesh.getName()} - ignore it`);
-                        generatedLODs.splice(i, 1);
+                    const level = lodInfo.level;
+                    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}\"`);
+                        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}\"`);
+                        shouldOmitLevel = true;
+                    }
+                    else if (!shouldOmitLevel) {
+                        // if the mesh vertex count difference to the last valid level is less than 32 vertices or less than 5% of the last level, we can omit this level
+                        const meshInfo = lodInfo.lodMeshInfo;
+                        const lastMeshInfo = generatedLODInfos[i - 1]?.lodMeshInfo;
+                        if (meshInfo && lastMeshInfo) {
+                            const vertexDifference = lastMeshInfo.totalVertexCount - meshInfo.totalVertexCount;
+                            const diffPercent = 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)}`);
+                                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)}`);
+                                shouldOmitLevel = true;
+                            }
+                        }
+                        if (shouldOmitLevel) {
+                            // we invalidate the cached entry because the mesh change was too small
+                            addToCache(lodInfo.cacheKey, new Uint8Array(0));
+                        }
+                    }
+                    if (shouldOmitLevel) {
+                        generatedLODInfos.splice(i, 1);
                         rmSync(fullPath);
                         i--;
                     }
+                    else {
+                        prevSize = sizeOnDisc;
+                    }
                 }
             }
             let maxDensity = 0;
             for (const prim of mesh.listPrimitives()) {
-                const lodsCount = generatedLODs.length;
+                const lodsCount = generatedLODInfos.length;
                 const lastLod = LODS[lodsCount];
-                console.log(`${NAME}: ${mesh.getName()} LOD ${LODS.length - 1}`);
+                console.log(`[${NAME}] ${mesh.getName()} LOD ${lodsCount}`);
                 const density = calculateMeshDensity(prim);
                 maxDensity = Math.max(maxDensity, density);
                 const task = simplifyMesh(doc, mesh, prim, lastLod);
@@ -403,18 +452,24 @@ export function make_progressive_meshes(filePath, _options, opts) {
             }
             await Promise.all(tasks);
             tasks.length = 0;
-            const model = progressiveExt.create({
-                guid: settings.guid,
-                uri: generatedLODs.map(l => l),
-                density: maxDensity,
-            });
-            mesh.setExtension(NEEDLE_PROGRESSIVE_EXTENSION_NAME, model);
-            index++;
-            if (!visited.has(settings.guid)) {
-                visited.set(settings.guid, {
-                    model: model,
-                    paths: generatedLODs,
+            const { totalVertexCount: totalVertexCountAfter } = getMeshInformation(mesh);
+            if (totalVertexCountAfter <= 0) {
+                logger.error(`ERR: [${NAME}] Mesh[${index}] has no vertices after simplification: ${mesh.getName()}`);
+            }
+            if (generatedLODInfos.length > 0) {
+                const model = progressiveExt.create({
+                    guid: settings.guid,
+                    uri: generatedLODInfos.map(l => l.path),
+                    density: maxDensity,
                 });
+                mesh.setExtension(NEEDLE_PROGRESSIVE_EXTENSION_NAME, model);
+                index++;
+                if (!visited.has(settings.guid)) {
+                    visited.set(settings.guid, {
+                        model: model,
+                        infos: generatedLODInfos,
+                    });
+                }
             }
         }
         console.log("< Progressive Mesh Transform: finished");
@@ -427,7 +482,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
  */
-async function createMeshLod(doc, basePath, level, mesh, guid, lodLevel, opts) {
+async function createMeshLod(doc, basePath, level, mesh, meshInfo, guid, lodLevel, opts) {
     const fileExtension = ".glb";
     const fileName_withoutExtension = "mesh_lod_" + level + "_" + guid;
     const fileName = fileName_withoutExtension + fileExtension;
@@ -445,9 +500,9 @@ async function createMeshLod(doc, basePath, level, mesh, guid, lodLevel, opts) {
         cacheKey = `mesh_lod_${level}_${hash}`;
         const cachedValue = tryGetFromCache(cacheKey);
         if (cachedValue) {
-            console.log(`${NAME}: ${mesh.getName()} LOD ${level} loaded ${(cachedValue.length / 1024).toFixed()} KB from cache`);
+            console.log(`[${NAME}] LOD ${level} loaded ${(cachedValue.length / 1024).toFixed()} KB from cache for \"${mesh.getName()}\"`);
             writeFileSync(outPath, cachedValue);
-            return { path: fileName, success: true };
+            return { level, path: fileName, success: true, cacheKey: cacheKey };
         }
     }
     const newDoc = new Document();
@@ -492,7 +547,6 @@ async function createMeshLod(doc, basePath, level, mesh, guid, lodLevel, opts) {
             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);
         }
     }
@@ -507,14 +561,11 @@ async function createMeshLod(doc, basePath, level, mesh, guid, lodLevel, opts) {
     }
     await Promise.all(tasks);
     tasks.length = 0;
-    // if we run simplify but the mesh didnt change
-    // if (didRunSimplification) {
-    // 	let anyPrimitiveDidChange = false;
-    // 	for (const res of results) {
-    // 		if (res) anyPrimitiveDidChange = true;
-    // 	}
-    // 	if (!anyPrimitiveDidChange) return false;
-    // }
+    const newMeshInformation = getMeshInformation(newMesh);
+    if (newMeshInformation.totalVertexCount < 4) {
+        console.error(`[${NAME}] mesh LOD ${level} is has less than 4 vertices → skipping`);
+        return { level, path: fileName, success: false, cacheKey: cacheKey };
+    }
     const progressiveExt = newDoc.createExtension(NEEDLE_progressive);
     if (!progressiveExt || !progressiveExt.create) {
         console.error("Failed to create progressive extension");
@@ -529,93 +580,20 @@ async function createMeshLod(doc, basePath, level, mesh, guid, lodLevel, opts) {
     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)}`);
+        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);
-    console.log(`${NAME}: Write mesh LOD ${level} to \"${fileName}\" with: ${JSON.stringify(lodLevel)}`);
+    console.log(`[${NAME}] Write mesh LOD ${level} with: ${JSON.stringify(lodLevel)} to \"${fileName}\"`);
     await newIo.write(outPath, newDoc);
+    // const hasChanged = meshInfo.maxVertexCount == newMeshInformation.maxVertexCount && meshInfo.totalVertexCount == newMeshInformation.totalVertexCount;
     // add to cache
     if (cacheKey != undefined) {
         const bytes = readFileSync(outPath);
         addToCache(cacheKey, bytes);
     }
-    return { path: fileName, success: true };
-}
-function calculateMeshDensity(prim) {
-    const bounds = {
-        min: [Infinity, Infinity, Infinity],
-        max: [-Infinity, -Infinity, -Infinity],
-    };
-    const position = prim.getAttribute('POSITION');
-    if (!position)
-        return -1;
-    let tempVec3 = [0, 0, 0];
-    for (let i = 0; i < position.getCount(); i++) {
-        tempVec3 = position.getElement(i, tempVec3);
-        expandBounds(tempVec3, bounds);
-    }
-    const indices = prim.getIndices();
-    let area = 0;
-    if (indices) {
-        // calculate surface area
-        const numIndices = indices.getCount();
-        const indexArray = indices.getArray();
-        const v0 = [0, 0, 0];
-        const v1 = [0, 0, 0];
-        const v2 = [0, 0, 0];
-        const e1 = [0, 0, 0];
-        const e2 = [0, 0, 0];
-        const boundSizeX = bounds.max[0] - bounds.min[0];
-        const boundSizeY = bounds.max[1] - bounds.min[1];
-        const boundSizeZ = bounds.max[2] - bounds.min[2];
-        const maxBounds = Math.max(boundSizeX, boundSizeY, boundSizeZ);
-        for (let i = 0; i < numIndices; i += 3) {
-            const i0 = indexArray[i + 0];
-            const i1 = indexArray[i + 1];
-            const i2 = indexArray[i + 2];
-            position.getElement(i0, v0);
-            position.getElement(i1, v1);
-            position.getElement(i2, v2);
-            e1[0] = v1[0] - v0[0];
-            e1[1] = v1[1] - v0[1];
-            e1[2] = v1[2] - v0[2];
-            e2[0] = v2[0] - v0[0];
-            e2[1] = v2[1] - v0[1];
-            e2[2] = v2[2] - v0[2];
-            // Normalize vertex distance in mesh bounds
-            e1[0] /= maxBounds;
-            e1[1] /= maxBounds;
-            e1[2] /= maxBounds;
-            e2[0] /= maxBounds;
-            e2[1] /= maxBounds;
-            e2[2] /= maxBounds;
-            // Cross product to get the area of the triangle
-            const cross = [
-                e1[1] * e2[2] - e1[2] * e2[1],
-                e1[2] * e2[0] - e1[0] * e2[2],
-                e1[0] * e2[1] - e1[1] * e2[0]
-            ];
-            // Add the area (half the magnitude of the cross product) to the total
-            area += Math.sqrt(cross[0] * cross[0] + cross[1] * cross[1] + cross[2] * cross[2]) / 2;
-        }
-    }
-    const count = indices.getCount() / 3;
-    const density = count / area;
-    // const size = [0, 0, 0] as vec3;
-    // size[0] = bounds.max[0] - bounds.min[0];
-    // size[1] = bounds.max[1] - bounds.min[1];
-    // size[2] = bounds.max[2] - bounds.min[2];
-    // const volume = size[0] * size[1] * size[2];
-    // const density = count / volume;
-    return density;
-    function expandBounds(point, target) {
-        for (let i = 0; i < 3; i++) {
-            target.min[i] = Math.min(point[i], target.min[i]);
-            target.max[i] = Math.max(point[i], target.max[i]);
-        }
-    }
+    return { level, path: fileName, success: true, lodMeshInfo: newMeshInformation, cacheKey: cacheKey };
 }
 async function simplifyMesh(doc, mesh, prim, lodinfo) {
     const weldOptions = {

package/dist/utils/guid.d.ts

@@ -0,0 +1 @@
+export declare function generateGuid(key: string): any;

package/dist/utils/guid.js

@@ -0,0 +1,5 @@
+import { v5 as uuidv5 } from 'uuid';
+const NEEDLE_BUILD_PIPELINE_NAMESPACE = '208dcaa6-1398-4d42-a625-8f5fc1cc1ccf';
+export function generateGuid(key) {
+    return uuidv5(key, NEEDLE_BUILD_PIPELINE_NAMESPACE);
+}

package/dist/utils/index.d.ts

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

package/dist/utils/index.js

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

package/dist/utils/mesh.d.ts

@@ -0,0 +1,7 @@
+import { Mesh, Primitive } from "@gltf-transform/core";
+export declare type MeshInformation = {
+    readonly maxVertexCount: number;
+    readonly totalVertexCount: number;
+};
+export declare function getMeshInformation(mesh: Mesh): MeshInformation;
+export declare function calculateMeshDensity(prim: Primitive): number;

package/dist/utils/mesh.js

@@ -0,0 +1,86 @@
+export function getMeshInformation(mesh) {
+    let maxVertexCount = 0;
+    const totalVertexCount = mesh.listPrimitives().reduce((acc, prim) => {
+        const vertices = prim.getAttribute('POSITION')?.getCount() || 0;
+        maxVertexCount = Math.max(maxVertexCount, vertices);
+        return acc + vertices;
+    }, 0);
+    return {
+        maxVertexCount,
+        totalVertexCount,
+    };
+}
+export function calculateMeshDensity(prim) {
+    const bounds = {
+        min: [Infinity, Infinity, Infinity],
+        max: [-Infinity, -Infinity, -Infinity],
+    };
+    const position = prim.getAttribute('POSITION');
+    if (!position)
+        return -1;
+    let tempVec3 = [0, 0, 0];
+    for (let i = 0; i < position.getCount(); i++) {
+        tempVec3 = position.getElement(i, tempVec3);
+        expandBounds(tempVec3, bounds);
+    }
+    const indices = prim.getIndices();
+    let area = 0;
+    if (indices) {
+        // calculate surface area
+        const numIndices = indices.getCount();
+        const indexArray = indices.getArray();
+        const v0 = [0, 0, 0];
+        const v1 = [0, 0, 0];
+        const v2 = [0, 0, 0];
+        const e1 = [0, 0, 0];
+        const e2 = [0, 0, 0];
+        const boundSizeX = bounds.max[0] - bounds.min[0];
+        const boundSizeY = bounds.max[1] - bounds.min[1];
+        const boundSizeZ = bounds.max[2] - bounds.min[2];
+        const maxBounds = Math.max(boundSizeX, boundSizeY, boundSizeZ);
+        for (let i = 0; i < numIndices; i += 3) {
+            const i0 = indexArray[i + 0];
+            const i1 = indexArray[i + 1];
+            const i2 = indexArray[i + 2];
+            position.getElement(i0, v0);
+            position.getElement(i1, v1);
+            position.getElement(i2, v2);
+            e1[0] = v1[0] - v0[0];
+            e1[1] = v1[1] - v0[1];
+            e1[2] = v1[2] - v0[2];
+            e2[0] = v2[0] - v0[0];
+            e2[1] = v2[1] - v0[1];
+            e2[2] = v2[2] - v0[2];
+            // Normalize vertex distance in mesh bounds
+            e1[0] /= maxBounds;
+            e1[1] /= maxBounds;
+            e1[2] /= maxBounds;
+            e2[0] /= maxBounds;
+            e2[1] /= maxBounds;
+            e2[2] /= maxBounds;
+            // Cross product to get the area of the triangle
+            const cross = [
+                e1[1] * e2[2] - e1[2] * e2[1],
+                e1[2] * e2[0] - e1[0] * e2[2],
+                e1[0] * e2[1] - e1[1] * e2[0]
+            ];
+            // Add the area (half the magnitude of the cross product) to the total
+            area += Math.sqrt(cross[0] * cross[0] + cross[1] * cross[1] + cross[2] * cross[2]) / 2;
+        }
+    }
+    const count = indices.getCount() / 3;
+    const density = count / area;
+    // const size = [0, 0, 0] as vec3;
+    // size[0] = bounds.max[0] - bounds.min[0];
+    // size[1] = bounds.max[1] - bounds.min[1];
+    // size[2] = bounds.max[2] - bounds.min[2];
+    // const volume = size[0] * size[1] * size[2];
+    // const density = count / volume;
+    return density;
+    function expandBounds(point, target) {
+        for (let i = 0; i < 3; i++) {
+            target.min[i] = Math.min(point[i], target.min[i]);
+            target.max[i] = Math.max(point[i], target.max[i]);
+        }
+    }
+}

package/index.mjs

@@ -35,8 +35,6 @@ try {
     runWithArgs("node pack-gltf.mjs");
     const durationInMinutes = ((Date.now() - startTime) / 1000 / 60).toFixed(1);
     console.log(`[Needle Build Pipeline] v${getVersion()} — Finished progressive transform and optimization in ${durationInMinutes} minutes.`);
-    // small delay to not close the process immediately and give external processes some time to read the output
-    await new Promise(resolve => setTimeout(resolve, 100));
 }
 catch (err) {
     console.error("Failed running commandline args:", err.message);

package/pack-gltf.mjs

@@ -97,7 +97,7 @@ async function packFile(file) {
         cacheKey = "packed-" + hash;
         const cached = tryGetFromCache(cacheKey);
         if (cached) {
-            console.log("→ Skip packing (loaded from cache): " + path.basename(file));
+            console.log(`→ Loaded compressed file from cache: \"${path.basename(file)}\"`);
             writeFileSync(file, cached);
             return;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@needle-tools/gltf-build-pipeline",
-  "version": "1.4.1-beta.7",
+  "version": "1.4.1-beta.9",
   "description": "Pipeline and tools for optimizing gltf files using gltf-transform and compression settings within glTF extensions",
   "main": "index.mjs",
   "type": "module",
@@ -31,7 +31,8 @@
     "p-limit": "3.1.0",
     "semver": "^7.3.7",
     "sharp": "^0.31.3",
-    "tmp": "^0.2.1"
+    "tmp": "^0.2.1",
+    "uuid": "^9.0.1"
   },
   "watch": {
     "compile": {