@needle-tools/gltf-build-pipeline 1.4.1-beta.6 → 1.4.1-beta.8

package/dist/transforms/needle_progressive.js

@@ -109,37 +109,37 @@ 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();
@@ -262,7 +262,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) {
@@ -331,12 +331,12 @@ export function make_progressive_meshes(filePath, _options, opts) {
             // 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;
             }
             // check if we have already produced LODs for this mesh
@@ -344,7 +344,7 @@ export function make_progressive_meshes(filePath, _options, opts) {
             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`);
+                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);
@@ -370,21 +370,25 @@ 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;
+            let omittedLevelsIndex = -1;
+            for (let i = 0; i < generatedLODs.length; i++) {
+                const filename = generatedLODs[i];
+                if (!filename) {
+                    console.log(`[${NAME}] LOD ${i} doesnt exist`);
                     continue;
                 }
-                const fullPath = outputDirectory + path;
+                const fullPath = outputDirectory + filename;
                 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`);
+                    prevSize = sizeOnDisc;
+                    if (diff == 0) {
+                        if (omittedLevelsIndex == -1)
+                            omittedLevelsIndex = i;
+                        console.log(`[${NAME}] LOD ${omittedLevelsIndex++} did not change mesh (${diff.toFixed(0)}) - level will be omitted \"${filename}\"`);
                         generatedLODs.splice(i, 1);
                         rmSync(fullPath);
                         i--;
@@ -395,7 +399,7 @@ export function make_progressive_meshes(filePath, _options, opts) {
             for (const prim of mesh.listPrimitives()) {
                 const lodsCount = generatedLODs.length;
                 const lastLod = LODS[lodsCount];
-                console.log(`${NAME}: ${mesh.getName()} LOD ${LODS.length - 1}`);
+                console.log(`[${NAME}] ${mesh.getName()} LOD ${LODS.length - 1}`);
                 const density = calculateMeshDensity(prim);
                 maxDensity = Math.max(maxDensity, density);
                 const task = simplifyMesh(doc, mesh, prim, lastLod);
@@ -445,7 +449,7 @@ 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 };
         }
@@ -492,7 +496,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);
         }
     }
@@ -529,12 +532,12 @@ 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);
     // add to cache
     if (cacheKey != undefined) {

package/index.mjs

@@ -34,7 +34,7 @@ try {
     runWithArgs("node make-progressive.mjs");
     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.`)
+    console.log(`[Needle Build Pipeline] v${getVersion()} — Finished progressive transform and optimization in ${durationInMinutes} minutes.`);
 }
 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.6",
+  "version": "1.4.1-beta.8",
   "description": "Pipeline and tools for optimizing gltf files using gltf-transform and compression settings within glTF extensions",
   "main": "index.mjs",
   "type": "module",