@needle-tools/gltf-build-pipeline 2.2.0-alpha.5 → 2.2.0-alpha.7

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).
 
+## [2.2.0-alpha.7] - 2023-06-13
+- fix: progressive transform of converted GLB files where meshes don't have indicies
+- fix: skip progressive texture generation for textures for textures that already match the lowest LOD size
+- fix: if compression is set to None the LOD textures should respect that setting and also not be compressed
+
 ## [2.2.0-alpha.5] - 2023-06-06
 - add: CLI `--progressive` option to `transform` command (default is true)
 - add: CLI `--compress` option to `transform` command (default is true)

package/dist/cache/cache.js

@@ -19,6 +19,7 @@ import { getVersion } from "../utils/version.js";
 //     return 0;
 // }
 const buildPipelineVersion = getVersion(false);
+const debugLogs = process.argv.includes("--debug");
 /**
  * Clear the cache.
  * This will remove all files in the cache directory.
@@ -86,7 +87,8 @@ export function limitCacheSize(maxSizeMB = cacheSizeLimit) {
 export function addToCache(key, bytes) {
     const dir = getCacheDirectory();
     const path = `${dir}/${key}.bin`;
-    console.log(`Added ${(bytes.byteLength / 1024).toFixed(1)} KB to cache at \"${path}\"`);
+    if (debugLogs)
+        console.log(`Added ${(bytes.byteLength / 1024).toFixed(1)} KB to cache at \"${path}\"`);
     fs.writeFileSync(path, bytes);
 }
 /**

package/dist/cli/index.js

@@ -77,7 +77,7 @@ Each version will be compressed and written to the output directory.
         logger.info("→ Transform " + file);
         const progressive_results = new Array();
         if (options.progressive === true) {
-            await make_progressive({
+            if (await make_progressive({
                 path: file,
                 results: progressive_results,
                 config,
@@ -86,7 +86,9 @@ Each version will be compressed and written to the output directory.
             }).catch(err => {
                 logger.error(err);
                 process.exit(ERROR_CODES.PROGRESSIVE_FAILED);
-            });
+            }) === false) {
+                process.exit(ERROR_CODES.PROGRESSIVE_FAILED);
+            }
         }
         if (options.compress === true) {
             const opts = {

package/dist/transforms/needle_progressive.d.ts

@@ -7,7 +7,7 @@ declare interface ProgressiveOptions {
     debug?: boolean;
     useCache?: boolean;
 }
-export declare function make_progressive(opts: ProgressiveOptions): Promise<void>;
+export declare function make_progressive(opts: ProgressiveOptions): Promise<boolean>;
 export declare function createTransform(name: string, fn: Transform): Transform;
 export declare function make_progressive_textures(filePath: string, _options: TextureResizeOptions, opts: ProgressiveOptions): Transform;
 /** Options for the {@link textureResize} function. */

package/dist/transforms/needle_progressive.js

@@ -14,14 +14,22 @@ import { compressPrimitive } from './needle_mesh_transform.js';
 import { calculateMeshDensity, getMeshInformation } from "../utils/mesh.js";
 export async function make_progressive(opts) {
     const file = opts.path;
-    return foreachGLTF(file, async (f) => {
+    let success = true;
+    await foreachGLTF(file, async (f) => {
+        // Should we stop if one file fails?
+        if (!success) {
+            return;
+        }
         // Don't re-process files that are already LODs
         if (isMeshLOD(f) || isImageLOD(f)) {
             console.log(`Progressive Transform: Ignore existing LOD file at ${f}`);
             return;
         }
-        await onProcess(f, opts);
+        const res = await onProcess(f, opts);
+        if (!res)
+            success = false;
     });
+    return success;
 }
 function registerExtensions(io) {
     registerDefaultExtensions(io);
@@ -39,10 +47,11 @@ function registerExtensions(io) {
 async function onProcess(file, opts) {
     if (!file.endsWith(".glb") && !file.endsWith(".gltf") && !file.endsWith(".vrm")) {
         console.log("ERR: file is not gltf/glb");
-        return;
+        return false;
     }
     if (!existsSync(file)) {
         console.log("ERR: file does not exist: " + file);
+        return false;
     }
     try {
         const io = new NodeIO();
@@ -85,7 +94,9 @@ async function onProcess(file, opts) {
     }
     catch (err) {
         console.log("ERR: failed to process file \"" + file + "\", Reason: " + err.message, "\nStack:\n" + err.stack);
+        return false;
     }
+    return true;
 }
 // basic idea:
 // 1. iterate all images that have an extension marking them to be progressively loaded
@@ -161,11 +172,15 @@ export function make_progressive_textures(filePath, _options = TEXTURE_RESIZE_DE
                 logger.debug(`[${NAME}] Skipping because progressive extension is not available. ${textureIndex}`);
                 continue;
             }
+            /** This is the current texture's size  */
+            const currentSize = Math.min(...texture.getSize());
+            if (currentSize <= settings.maxSize) {
+                logger.debug(`[${NAME}] Skipping, texture[${textureIndex}] is already smaller than the requested size: ${currentSize}px <= ${settings.maxSize}px`);
+                continue;
+            }
             const textureGuid = settings.guid?.length ? settings.guid : generateGuid(filename + "_texture_" + index.toString());
             /** This is the size of the texture that is embedded in the glTF. No LOD should be smaller than this */
             const maxSize = settings.maxSize;
-            /** This is the current texture's size  */
-            const currentSize = Math.min(...texture.getSize());
             const LOD_LEVEL = new Array();
             LOD_LEVEL.push({ size: currentSize });
             let generateLods = true; //opts.config?.usecase === "world";
@@ -302,27 +317,32 @@ async function createTextureLod(args, opts) {
         // Make sure the material is used
         createMeshForMaterial(newDoc, newMaterial, slot_index++);
     }
-    const compressionSettings = texture.getExtension(NEEDLE_compression_texture.EXTENSION_NAME);
-    if (compressionSettings !== undefined && compressionSettings !== null && compressionSettings.getExtensionDefinition) {
+    const compressionSettingsExt = texture.getExtension(NEEDLE_compression_texture.EXTENSION_NAME);
+    if (compressionSettingsExt !== undefined && compressionSettingsExt !== null && compressionSettingsExt.getExtensionDefinition) {
         logger.info("> Pass compression extension to new texture");
         const newExt = newDoc.createExtension(NEEDLE_compression_texture);
-        const def = compressionSettings.getExtensionDefinition();
-        switch (opts.config.usecase) {
-            // For world scenarios we use ETC1S
-            case "world":
-                def.mode = "ETC1S";
-                break;
-            case "product":
-                def.mode = detectTextureCompressionMode(slots);
-                def.quality = 100;
-                break;
-            default:
-                def.mode = detectTextureCompressionMode(slots);
-                break;
+        const compressionSettings = compressionSettingsExt.getExtensionDefinition();
+        if (compressionSettings?.mode === "none") {
+            // if the mode is set to None then we keep that setting for the new texture
+        }
+        else {
+            switch (opts.config.usecase) {
+                // For world scenarios we use ETC1S
+                case "world":
+                    compressionSettings.mode = "ETC1S";
+                    break;
+                case "product":
+                    compressionSettings.mode = detectTextureCompressionMode(slots);
+                    compressionSettings.quality = 100;
+                    break;
+                default:
+                    compressionSettings.mode = detectTextureCompressionMode(slots);
+                    break;
+            }
         }
-        def.slot = slots[0];
-        const newProp = newExt.create(def);
-        newTexture.setExtension(NEEDLE_compression_texture.EXTENSION_NAME, newProp);
+        compressionSettings.slot = slots[0];
+        const newCompressionSettings = newExt.create(compressionSettings);
+        newTexture.setExtension(NEEDLE_compression_texture.EXTENSION_NAME, newCompressionSettings);
     }
     // add progressive texture extension
     const progressiveExt = newDoc.createExtension(NEEDLE_progressive);
@@ -688,7 +708,8 @@ function clonePrimitiveData(prim, logger) {
     if (semantics.some(s => s.includes("JOINTS"))) {
         return null;
     }
-    const indices = new Uint32Array(prim.getIndices().getArray());
+    const prevIndices = prim.getIndices();
+    const indices = !prevIndices ? null : new Uint32Array(prevIndices.getArray());
     const attributes = {};
     for (const attr of semantics) {
         logger.info(`[${NAME}] Clone attribute ${attr}`);
@@ -753,7 +774,7 @@ async function createMeshLod(doc, basePath, level, mesh, meshInfo, guid, lodLeve
     newNode.setName("LOD " + level + "_" + guid);
     newNode.setTranslation([0, 0, 0]);
     const newMesh = newDoc.createMesh();
-    newMesh.setName(mesh.getName() + " LOD " + level);
+    newMesh.setName((mesh.getName() || "Unnamed") + " LOD " + level);
     newNode.setMesh(newMesh);
     const newMat = newDoc.createMaterial();
     const weights = mesh.getWeights();

package/dist/utils/mesh.d.ts

@@ -5,4 +5,9 @@ export declare type MeshInformation = {
     readonly totalIndexCount: number;
 };
 export declare function getMeshInformation(mesh: Mesh): MeshInformation;
-export declare function calculateMeshDensity(prim: Primitive): number;
+/**
+ * Calculate the density of a mesh.
+ * @param prim - The primitive to calculate the density for.
+ * @returns The density of the mesh or -1 if the mesh is not indexed.
+ */
+export declare function calculateMeshDensity(prim: Primitive): number | -1;

package/dist/utils/mesh.js

@@ -14,6 +14,11 @@ export function getMeshInformation(mesh) {
         totalIndexCount,
     };
 }
+/**
+ * Calculate the density of a mesh.
+ * @param prim - The primitive to calculate the density for.
+ * @returns The density of the mesh or -1 if the mesh is not indexed.
+ */
 export function calculateMeshDensity(prim) {
     const bounds = {
         min: [Infinity, Infinity, Infinity],
@@ -71,16 +76,17 @@ export function calculateMeshDensity(prim) {
             // 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;
     }
-    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;
+    return -1;
     function expandBounds(point, target) {
         for (let i = 0; i < 3; i++) {
             target.min[i] = Math.min(point[i], target.min[i]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@needle-tools/gltf-build-pipeline",
-  "version": "2.2.0-alpha.5",
+  "version": "2.2.0-alpha.7",
   "description": "Pipeline and tools for optimizing gltf files using gltf-transform and compression settings within glTF extensions",
   "main": "dist/index.js",
   "type": "module",