@needle-tools/gltf-build-pipeline 1.6.0-alpha.1 → 1.6.0-alpha.3

package/CHANGELOG.md

@@ -4,7 +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).
 
-## [1.6.0-alpha] - 2023-05-27
+## [1.6.0-alpha.3] - 2023-05-28
+- fix: determine build pipeline version
+
+## [1.6.0-alpha.2] - 2023-05-27
 - add: `gltf-build-pipeline` commandline support with `transform` and `compress` (pack-gltf) options.
 
 ## [1.5.0-alpha.12] - 2023-05-20

package/README.md

@@ -0,0 +1,17 @@
+# glTF Build Pipeline
+
+Creating optimized glTF, GLB and VRM files for the web.   
+Includes support for generating LOD quality level for textures and meshes that can be used with [@needle-tools/gltf-progressive](https://www.npmjs.com/package/@needle-tools/gltf-progressive)
+
+## Examples
+
+- [Example on Github](https://github.com/needle-engine/progressive-meshes-sample)
+
+
+
+# Contact ✒️
+<b>[🌵 needle — tools for creators](https://needle.tools)</b> • 
+[Twitter](https://twitter.com/NeedleTools) • 
+[Discord](https://discord.needle.tools) • 
+[Forum](https://forum.needle.tools)
+

package/dist/cache/cache.d.ts

@@ -5,6 +5,7 @@ import { Logger } from "@donmccurdy/caporal";
  * This will remove all files in the cache directory.
  */
 export declare function clearCache(logger?: Logger): void;
+export declare const cacheSizeLimit = 1024;
 /**
  * Ensure that the cache size does not exceed the given maximum size in MB.
  * @param maxSizeMB The maximum size in MB.

package/dist/cache/cache.js

@@ -31,11 +31,12 @@ export function clearCache(logger) {
     else
         logger.info(`Cleared cache at ${dir}`);
 }
+export const cacheSizeLimit = 1024;
 /**
  * Ensure that the cache size does not exceed the given maximum size in MB.
  * @param maxSizeMB The maximum size in MB.
  */
-export function limitCacheSize(maxSizeMB = 1024) {
+export function limitCacheSize(maxSizeMB = cacheSizeLimit) {
     const dir = getCacheDirectory(true);
     console.log(`Limit cache size to ${maxSizeMB.toFixed(2)} MB at ${dir}...`);
     let totalSize = 0;
@@ -213,7 +214,7 @@ export function getHash(property, level = 0) {
     }
     return hash;
 }
-const cleanBuildPipelineVersion = buildPipelineVersion.replace(/[^a-zA-Z0-9]/g, "_");
+const cleanBuildPipelineVersion = getVersion(false).replace(/[^a-zA-Z0-9]/g, "_");
 function getCacheDirectory(root) {
     const tmpDir = path.join(tmp.tmpdir, "Needle", "build-pipeline-cache", root ? "" : cleanBuildPipelineVersion);
     if (!fs.existsSync(tmpDir)) {

package/dist/cli/index.js

@@ -1,11 +1,14 @@
 #! /usr/bin/env node
 import { program } from '@donmccurdy/caporal';
 import { packGLTF } from "../scripts/index.js";
-import { printStats } from '../utils/stats.js';
+import { printStats, writeFileStatsToFile } from '../utils/stats.js';
 import { getVersion } from '../utils/version.js';
 import { UsecaseOptions, createConfig, getConfig } from '../config/index.js';
 import { make_progressive } from '../transforms/needle_progressive.js';
-import { clearCache } from '../cache/cache.js';
+import { cacheSizeLimit, clearCache } from '../cache/cache.js';
+import { existsSync, statSync } from 'fs';
+import { foreachGLTF } from '../utils/fileutils.js';
+import { dirname } from 'path';
 // For testing / dev you can run `npm link` in the package directory
 // For removing the link run `npm rm --global @needle-tools/gltf-build-pipeline`
 program
@@ -14,21 +17,22 @@ program
     logger.info(getVersion());
 })
     .command("clear-caches", "Clear all caches")
-    .help(`
-Clear all caches.
+    .help(`Clears all cached files
+Caches are limited to ${cacheSizeLimit} MB disc space by default.
 `)
     .action(async ({ logger }) => {
     logger.info("Clearing caches");
     clearCache(logger);
 })
-    .command("compress", "Compress a glTF file")
+    .command("compress", "Compress glTF, GLB or VRM files")
     .help(`
 Compress a single glTF file. The input file is compressed and written to the output file.  
 `)
-    .argument('<input>', "The input glTF, GLB or VRM file that should be compressed")
-    .option("--usecase <usecase>", `The usecase for the compression. This will set the compression settings. Options are ${UsecaseOptions.join(", ")}`, { validator: program.STRING })
+    .argument('<input>', "The input glTF, GLB or VRM file that should be compressed OR a directory that contains files to be compressed")
+    .option("--usecase <usecase>", `The usecase for the compression. This will set the compression settings. Possible options: [${UsecaseOptions.join(", ")}] e.g. \`--usecase ${UsecaseOptions[0]}\"`, { validator: program.STRING })
     .option("--config <config>", "The path to a JSON file containing the compression settings. This can also be a needle.config.json file with a \"compression\" object or usecase string.", { validator: program.STRING })
     .option("--output <output>", "The output file. If not provided, the input file will be overwritten.", { validator: program.STRING })
+    .option("--output-stats", "The path to a JSON file where the stats will be written to.", { validator: program.STRING })
     .action(async ({ logger, args, options }) => {
     logger.info("Transforming glTF file: " + args.input);
     const stats = {
@@ -41,28 +45,64 @@ Compress a single glTF file. The input file is compressed and written to the out
     let config = getConfig(options.config?.toString());
     if (options.usecase) {
         logger.info("Using usecase: " + options.usecase);
-        config = { ...config, ...createConfig(options.usecase.toString()) };
+        config = { ...createConfig(options.usecase.toString()), ...config, };
+        if (config.usecase != "unknown" && config.usecase != options.usecase.toString()) {
+            logger.warn(`Conflicting usecase. Your specific config at \"${options.config}\" has a different usecase than the one provided by the CLI: \"${options.usecase}\". Using the usecase from the config file.`);
+        }
+        else {
+            config.usecase = options.usecase.toString();
+        }
     }
     const file = args.input.toString();
+    const outDir = statSync(file).isDirectory() ? file : dirname(file);
+    let outputIsDirectory = false;
+    if (statSync(file).isDirectory() && options.output) {
+        if (statSync(options.output.toString()).isDirectory()) {
+            outputIsDirectory = true;
+            if (!existsSync(options.output.toString())) {
+                logger.error("Output directory does not exist: " + options.output.toString());
+                return;
+            }
+        }
+        else {
+            logger.error("--output must be a directory if input is a directory");
+            return;
+        }
+    }
+    const file_stats = [];
     const set = new Set();
-    await packGLTF(file, options.output?.toString() || file, {
-        config,
-        packedFiles: set,
-        stats,
-        debug: false,
-        useCache: true,
+    await foreachGLTF(file, async (file) => {
+        let outputFile = options.output?.toString() || file;
+        if (outputIsDirectory) {
+            const filename = file.replaceAll("\\", "/").split("/").pop();
+            outputFile = options.output?.toString() + "/" + filename;
+        }
+        await packGLTF(file, outputFile, {
+            config,
+            packedFiles: set,
+            stats,
+            debug: false,
+            useCache: true,
+            logger: logger,
+            file_stats: file_stats,
+        });
     });
     printStats(stats);
+    console.log("Stats: ", options);
+    if (options.outputStats) {
+        writeFileStatsToFile(file_stats, options.outputStats.toString());
+    }
 })
-    .command("transform", "Transform a glTF file")
+    .command("transform", "Transform (progressive loading) and compress glTF, GLB or VRM files")
     .help(`
 This will produce multiple versions of the input file, each with a different level of optimization.   
 Each version will be compressed and written to the output directory.
 `)
-    .argument('<input>', "The input glTF, GLB or VRM file that should be compressed")
-    .option("--usecase <usecase>", `The usecase for the compression. This will set the compression settings. Options are ${UsecaseOptions.join(", ")}`, { validator: program.STRING })
+    .argument('<input>', "The input glTF, GLB or VRM file that should be compressed OR a directory that contains files to be compressed")
+    .option("--usecase <usecase>", `The usecase for the compression. This will set the compression settings. Possible options: [${UsecaseOptions.join(", ")}]`, { validator: program.STRING })
     .option("--config <config>", "The path to a JSON file containing the compression settings. This can also be a needle.config.json file with a \"compression\" object or usecase string.", { validator: program.STRING })
-    // .option("--output <output>", "The output file. If not provided, the input file will be overwritten.", { validator: program.STRING })
+    // .option("--output <output>", "The output directory. If not provided, the input files will be overwritten.", { validator: program.STRING })
+    .option("--output-stats", "The path to a JSON file where the stats will be written to.", { validator: program.STRING })
     .action(async ({ logger, args, options }) => {
     logger.info("Transforming glTF file: " + args.input);
     const stats = {
@@ -75,28 +115,47 @@ Each version will be compressed and written to the output directory.
     let config = getConfig(options.config?.toString());
     if (options.usecase) {
         logger.info("Using usecase: " + options.usecase);
-        config = { ...config, ...createConfig(options.usecase.toString()) };
+        config = { ...createConfig(options.usecase.toString()), ...config, };
+        if (config.usecase != "unknown" && config.usecase != options.usecase.toString()) {
+            logger.warn(`Conflicting usecase. Your specific config at \"${options.config}\" has a different usecase than the one provided by the CLI: \"${options.usecase}\". Using the usecase from the config file.`);
+        }
+        else {
+            config.usecase = options.usecase.toString();
+        }
     }
     const file = args.input.toString();
-    const progressive_results = new Array();
-    await make_progressive({
-        path: file,
-        results: progressive_results,
-        config,
-        debug: false,
-        useCache: true,
+    const outDir = statSync(file).isDirectory() ? file : dirname(file);
+    const file_stats = [];
+    const set = new Set();
+    await foreachGLTF(file, async (file) => {
+        logger.info("> Transform " + file);
+        const progressive_results = new Array();
+        await make_progressive({
+            path: file,
+            results: progressive_results,
+            config,
+            debug: false,
+            useCache: true,
+        });
+        const opts = {
+            config,
+            stats,
+            packedFiles: set,
+            debug: false,
+            useCache: true,
+            logger: logger,
+            file_stats,
+        };
+        for (const res of progressive_results) {
+            logger.info("> Compress " + res);
+            await packGLTF(res, res, opts);
+        }
+        logger.info("> Compress " + file);
+        await packGLTF(file, file, opts);
     });
-    console.log("Progressive results: ", progressive_results);
-    const opts = {
-        config,
-        stats,
-        debug: false,
-        useCache: true,
-    };
-    for (const prog of progressive_results) {
-        await packGLTF(prog, prog, opts);
-    }
-    await packGLTF(file, file, opts);
     printStats(stats);
+    if (options.outputStats) {
+        writeFileStatsToFile(file_stats, options.outputStats.toString());
+    }
 });
 program.run();

package/dist/config/index.d.ts

@@ -1,4 +1,4 @@
-declare type Usecase = "unknown" | "product" | "game" | "metaverse";
+declare type Usecase = "unknown" | "product" | "world";
 export declare const UsecaseOptions: string[];
 /**
  * The config object contains information about how a file should be processed.

package/dist/config/index.js

@@ -1,5 +1,5 @@
 import { existsSync, readFileSync } from "fs";
-export const UsecaseOptions = ["product", "game", "metaverse"];
+export const UsecaseOptions = ["product"];
 const defaultConfig = {
     usecase: "unknown",
 };
@@ -101,25 +101,38 @@ function internalResolveConfig() {
 function resolveConfig(filename, content) {
     // Handle config being part of `needle.config.json`
     if (filename.endsWith("needle.config.json")) {
-        const config = JSON.parse(content);
-        if (config.optimization) {
-            console.log("INFO: Found optimization config at \"" + filename + "\".");
-            // If the optimization config is a string, it's the usecase
-            if (typeof config.optimization === "string") {
-                return createConfig(config.optimization);
+        try {
+            const config = JSON.parse(content);
+            if (config.optimization) {
+                console.log("INFO: Found optimization config at \"" + filename + "\".");
+                // If the optimization config is a string, it's the usecase
+                if (typeof config.optimization === "string") {
+                    return createConfig(config.optimization);
+                }
+                return config.optimization;
+            }
+            else {
+                console.log("INFO: No optimization config found in needle.config.json. Using default config.");
+                return null;
             }
-            return config.optimization;
         }
-        else {
-            console.log("INFO: No optimization config found in needle.config.json. Using default config.");
-            return null;
+        catch (err) {
+            console.error(`ERR: Failed parsing config \"${err.message}\" at ${filename}`);
         }
     }
     // Handle config being the content of the file
     else if (content.trimStart().startsWith("{")) {
-        return JSON.parse(content);
+        try {
+            return JSON.parse(content);
+        }
+        catch (err) {
+            if (err instanceof Error)
+                console.error(`ERR: Failed parsing config \"${err.message}\" at ${filename}`);
+            else
+                console.error(`ERR: Failed parsing config \"${err}\" at ${filename}`);
+        }
     }
     else {
-        throw new Error("Invalid config file format. Expected JSON object.");
+        console.error("ERR: Invalid config file format. Expected JSON object at " + filename);
     }
 }

package/dist/scripts/pack-gltf.d.ts

@@ -1,11 +1,14 @@
-import { Stats } from "../utils/index.js";
+import { ILogger } from '@gltf-transform/core';
+import { FileStats, Stats } from "../utils/index.js";
 import { Config } from '../config/index.js';
 export type PackGLTFOptions = {
     debug: boolean;
     useCache: boolean;
     packedFiles?: Set<string>;
     stats?: Stats;
+    file_stats: FileStats[] | null;
     config?: Config;
+    logger?: ILogger;
 };
 /** Compress a glTF file
  */

package/dist/scripts/pack-gltf.js

@@ -1,5 +1,5 @@
 import path from 'path';
-import { NodeIO } from '@gltf-transform/core';
+import { Logger, NodeIO, Verbosity } from '@gltf-transform/core';
 import { ALL_EXTENSIONS } from '@gltf-transform/extensions';
 import draco3d from 'draco3dgltf';
 import { existsSync, readFileSync, statSync, writeFileSync } from 'fs';
@@ -7,17 +7,20 @@ import { MeshoptDecoder, MeshoptEncoder } from 'meshoptimizer';
 import { resample } from '@gltf-transform/functions';
 import { ALL_EXTENSIONS as NEEDLE_EXTENSIONS, NEEDLE_compression_texture, NEEDLE_mesh_compression, } from '../extensions/index.js';
 import { isMeshLOD, needle_animation_transform, needle_asset, needle_mesh_transform, needle_texture_transform, } from '../transforms/index.js';
-import { writeNodeIO } from "../utils/index.js";
+import { createNewFilestats, writeNodeIO } from "../utils/index.js";
 import { addToCache, getHash, tryGetFromCache, } from "../cache/index.js";
 import { getConfig } from '../config/index.js';
 /** Compress a glTF file
  */
 export async function packGLTF(inputFile, outputFile, options) {
+    if (!options.logger) {
+        options.logger = new Logger(Verbosity.INFO);
+    }
+    const { debug, stats, packedFiles, useCache, logger } = options;
     if (!existsSync(inputFile)) {
-        console.error("WARN: can not pack, file does not exist: " + inputFile);
+        logger.error("WARN: can not pack, file does not exist: " + inputFile);
         return;
     }
-    const { debug, stats, packedFiles, useCache } = options;
     if (debug && inputFile.includes(".debug.")) {
         return;
     }
@@ -31,7 +34,7 @@ export async function packGLTF(inputFile, outputFile, options) {
         cacheKey = "packed-" + hash;
         const cached = tryGetFromCache(cacheKey);
         if (cached) {
-            console.log(`→ Loaded compressed file from cache: \"${path.basename(inputFile)}\"`);
+            logger.info(`→ Loaded compressed file from cache: \"${path.basename(inputFile)}\"`);
             writeFileSync(inputFile, cached);
             return;
         }
@@ -44,7 +47,7 @@ export async function packGLTF(inputFile, outputFile, options) {
     try {
         const config = options.config || getConfig();
         const prevSizeInMB = statSync(inputFile).size / 1024 / 1024;
-        console.log(`→ Compressing ${prevSizeInMB.toFixed(1)} MB: ${inputFile}`);
+        logger.info(`→ Compressing ${prevSizeInMB.toFixed(1)} MB: ${inputFile}`);
         // const isProgressiveAsset = isLOD(file);
         const startTime = Date.now();
         const io = new NodeIO()
@@ -62,8 +65,8 @@ export async function packGLTF(inputFile, outputFile, options) {
         });
         const document = await io.read(inputFile);
         /** @ts-ignore */
-        document.getLogger().verbosity = 0;
-        let totalGPUTextureMemmory = 0;
+        document.getLogger().verbosity = Verbosity.ERROR;
+        let totalGPUTextureMemory = 0;
         /** @type {Array<import('@gltf-transform/core').Transform>} */
         const transforms = [
             needle_asset(),
@@ -73,8 +76,7 @@ export async function packGLTF(inputFile, outputFile, options) {
                 noToktx: false,
                 debug: debug,
                 reportGPUMemory: val => {
-                    if (stats)
-                        stats.totalGPUMemoryInMB += val;
+                    totalGPUTextureMemory += val;
                 },
                 config,
             }),
@@ -99,18 +101,22 @@ export async function packGLTF(inputFile, outputFile, options) {
         const duration = Date.now() - startTime;
         const sizeInMB = statSync(outputFile).size / 1024 / 1024;
         const filename = path.basename(outputFile);
-        const gpuMemoryInMB = totalGPUTextureMemmory / 1024 / 1024;
-        console.log(`← Compressing done in ${(duration / 1000).toFixed(1)} sec, ${prevSizeInMB.toFixed(1)} MB → ${sizeInMB.toFixed(1)} MB (GPU: ${gpuMemoryInMB.toFixed(1)} MB textures): ${filename} at ${outputFile}`);
+        const gpuMemoryInMB = totalGPUTextureMemory / 1024 / 1024;
+        logger.info(`← Compressing done in ${(duration / 1000).toFixed(1)} sec, ${prevSizeInMB.toFixed(1)} MB → ${sizeInMB.toFixed(1)} MB (GPU: ${gpuMemoryInMB.toFixed(1)} MB textures): ${filename} at ${outputFile}`);
         if (stats) {
             stats.totalFilesProcessed++;
             stats.totalFileSizeInMB += sizeInMB;
             stats.totalFileSizeInMBBefore += prevSizeInMB;
             stats.totalGPUMemoryInMB += gpuMemoryInMB;
         }
+        const filestats = createNewFilestats(outputFile, document, {
+            gpu_memory: totalGPUTextureMemory,
+        });
+        options.file_stats?.push(filestats);
         return true;
     }
     catch (err) {
-        console.error("ERR: packing " + inputFile + " failed: " + err.message);
+        logger.error("ERR: packing " + inputFile + " failed: " + err.message);
         if (debug)
             throw err;
         return false;

package/dist/transforms/needle_progressive.d.ts

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

package/dist/transforms/needle_progressive.js

@@ -69,11 +69,15 @@ async function onProcess(file, opts) {
                     return;
                 }
             }
+            let smallesTextureSize = 128;
+            if (opts.config.usecase === "product") {
+                smallesTextureSize = 512;
+            }
             //@ts-ignore
             document.getLogger().verbosity = 0;
             const transforms = [
                 needle_asset(),
-                make_progressive_textures(file, { size: [256, 256] }, opts),
+                make_progressive_textures(file, { size: [smallesTextureSize, smallesTextureSize] }, opts),
                 sparse(),
             ];
             // TODO: progressive meshes aren't supported yet for VRMs
@@ -143,14 +147,14 @@ export function make_progressive_textures(filePath, _options = TEXTURE_RESIZE_DE
             let settings = texture.getExtension(NEEDLE_progressive_texture_settings.EXTENSION_NAME);
             if (!settings) {
                 const size = texture.getSize();
-                if (size?.length >= 2 && size[0] <= 128 && size[1] <= 128) {
-                    logger.warn(`[${NAME}] Skipping texture[${textureIndex}], no settings found and the texture is already < 128x128`);
+                if (size?.length >= 2 && size[0] <= options.size[0] && size[1] <= options.size[1]) {
+                    logger.warn(`[${NAME}] Skipping texture[${textureIndex}], no settings found and the texture is already <= ${size[0]}x${size[1]}`);
                     continue;
                 }
                 else {
                     settings = {
                         guid: generateGuid(filename + "_texture_" + index.toString()),
-                        maxSize: 128,
+                        maxSize: _options.size[0],
                     };
                     logger.debug(`[${NAME}] No settings found for texture[${index}] - will use default settings (maxSize: ${settings.maxSize}, guid: ${settings.guid})`);
                 }
@@ -360,7 +364,10 @@ export function make_progressive_meshes(filePath, _options, opts) {
         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;
+        let MAX_LODS = 6;
+        if (opts.config.usecase === "product") {
+            MAX_LODS = 3;
+        }
         const LODS = [
             {
                 ratio: 1,
@@ -369,10 +376,13 @@ 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;
             const latest = LODS[LODS.length - 1];
             const ratio = latest.ratio * .5;
-            const error = Math.min(.013 * (l + 1), 0.05);
+            let error = Math.min(.013 * (l + 1), 0.05);
+            if (opts.config.usecase === "product") {
+                error *= .5;
+            }
             LODS.push({
                 ratio: ratio,
                 error,
@@ -626,6 +636,7 @@ async function createMeshLod(doc, basePath, level, mesh, meshInfo, guid, lodLeve
         mesh["needle:mesh-hash"] = hash;
     }
     hash += getHash(lodLevel);
+    hash += getHash(opts.config);
     if (opts.useCache !== false) {
         cacheKey = `mesh_lod_${level}_${hash}`;
         const cachedValue = tryGetFromCache(cacheKey);

package/dist/utils/fileutils.d.ts

@@ -1,3 +1,4 @@
+export declare function getFileName(filepath: string): string;
 export declare type GLTFFileCallback = (file: string) => void | Promise<void>;
 export declare function foreachGLTF(args: string | string[], callback: GLTFFileCallback): Promise<void>;
 export declare function replaceExtension(filepath: string, newExtension: string): string;

package/dist/utils/fileutils.js

@@ -1,23 +1,27 @@
 import { existsSync, statSync, readdirSync, readFileSync } from 'fs';
 import { isAbsolute } from 'path';
+export function getFileName(filepath) {
+    const parts = filepath.replaceAll("\\", "/").split("/");
+    return parts[parts.length - 1];
+}
 export async function foreachGLTF(args, callback) {
     // get original directory this run was invoked from
     const initDir = process.env.INIT_CWD;
     const context = {
         baseDirectory: initDir,
-        filesFound: 0
+        files: [],
     };
     // traverse recursively through all files and directories
     if (Array.isArray(args)) {
         for (const arg of args) {
-            await testEntry(arg, callback, context);
+            await testEntry(arg, context);
         }
     }
     else if (typeof args === "string") {
-        await testEntry(args, callback, context);
+        await testEntry(args, context);
     }
     // try to run with needle config
-    if (context.filesFound <= 0 && context.baseDirectory) {
+    if (context.files?.length <= 0 && context.baseDirectory) {
         const needleConfigPath = context.baseDirectory + "/needle.config.json";
         if (existsSync(needleConfigPath)) {
             const config = JSON.parse(readFileSync(needleConfigPath, "utf8"));
@@ -26,13 +30,13 @@ export async function foreachGLTF(args, callback) {
                 // If it's an absolute path
                 if (existsSync(buildDirectory)) {
                     console.log("INFO: Using build directory from needle.config.json: " + buildDirectory);
-                    await testEntry(buildDirectory, callback, context);
+                    await testEntry(buildDirectory, context);
                 }
                 else { // if its a relative path
                     const newPath = context.baseDirectory + "/" + buildDirectory;
                     if (existsSync(newPath)) {
                         console.log("INFO: Using build directory from needle.config.json: " + newPath);
-                        await testEntry(newPath, callback, context);
+                        await testEntry(newPath, context);
                     }
                 }
             }
@@ -43,11 +47,16 @@ export async function foreachGLTF(args, callback) {
             // await testEntry(context.baseDirectory + "/dist", callback, context);
         }
     }
-    if (context.filesFound <= 0) {
+    if (context.files.length <= 0) {
         console.log("WARN: No glTF files found. Make sure to invoke with a valid path to a glTF file or directory. This path may be relative to " + initDir);
     }
+    else {
+        for (const file of context.files) {
+            await callback(file);
+        }
+    }
 }
-async function testEntry(entry, callback, context) {
+async function testEntry(entry, context) {
     // ignore argument names (e.g. --debug)
     if (entry.startsWith("--")) {
         return false;
@@ -90,11 +99,7 @@ async function testEntry(entry, callback, context) {
         }
     }
     if (entry.endsWith(".glb") || entry.endsWith(".gltf") || entry.endsWith(".vrm")) {
-        context.filesFound += 1;
-        const res = callback(entry);
-        if (res instanceof Promise) {
-            await res;
-        }
+        context.files.push(entry);
     }
     else {
         const stat = statSync(entry);
@@ -105,7 +110,7 @@ async function testEntry(entry, callback, context) {
             }
             const files = readdirSync(entry);
             for (const file of files) {
-                await testEntry(entry + "/" + file, callback, context);
+                await testEntry(entry + "/" + file, context);
             }
         }
         else {

package/dist/utils/stats.d.ts

@@ -1,3 +1,5 @@
+import { Logger } from "@donmccurdy/caporal";
+import { Document } from "@gltf-transform/core";
 export type Stats = {
     startTime: number;
     totalGPUMemoryInMB: number;
@@ -5,4 +7,17 @@ export type Stats = {
     totalFileSizeInMB: number;
     totalFileSizeInMBBefore: number;
 };
-export declare function printStats(stats: any): void;
+export declare function printStats(stats: Stats, logger?: Logger): void;
+export type FileStats = {
+    filename: string;
+    /** Size in bytes */
+    size: number;
+    gpu_memory: number;
+    vertex_count: number;
+    nodes: number;
+    materials: number;
+};
+export declare function createNewFilestats(file: string, document: Document, stats: {
+    gpu_memory: number;
+}): FileStats;
+export declare function writeFileStatsToFile(filestats: FileStats[], output_path: string): void;

package/dist/utils/stats.js

@@ -1,6 +1,39 @@
 import { getVersion } from "./version.js";
-export function printStats(stats) {
+import { getFileName } from "./fileutils.js";
+import { statSync, writeFileSync } from "fs";
+export function printStats(stats, logger) {
     const duration = Date.now() - stats.startTime;
     const durationInMinutes = duration / 1000 / 60;
-    console.log(`[Needle Build Pipeline] v${getVersion()} — Finished packing ${stats.totalFilesProcessed} files in ${durationInMinutes.toFixed(1)} minutes; total size ${stats.totalFileSizeInMBBefore.toFixed(1)} MB → ${stats.totalFileSizeInMB.toFixed(1)} MB, total GPU memory: ${stats.totalGPUMemoryInMB.toFixed(1)} MB`);
+    const msg = `[Needle Build Pipeline] v${getVersion()} — Finished packing ${stats.totalFilesProcessed} files in ${durationInMinutes.toFixed(1)} minutes; total size ${stats.totalFileSizeInMBBefore.toFixed(1)} MB → ${stats.totalFileSizeInMB.toFixed(1)} MB, total GPU memory: ${stats.totalGPUMemoryInMB.toFixed(1)} MB`;
+    if (logger)
+        logger.info(msg);
+    else
+        console.log(msg);
+}
+export function createNewFilestats(file, document, stats) {
+    const filename = getFileName(file);
+    const root = document.getRoot();
+    const filestats = {
+        filename,
+        size: statSync(file).size,
+        gpu_memory: stats.gpu_memory,
+        nodes: root.listNodes().length,
+        materials: root.listMaterials().length,
+        vertex_count: 0,
+    };
+    // Count vertices
+    for (const mesh of root.listMeshes()) {
+        filestats.vertex_count += mesh.listPrimitives().reduce((acc, p) => acc + p.getAttribute('POSITION').getCount(), 0);
+    }
+    filestats.vertex_count = Math.round(filestats.vertex_count / 3);
+    return filestats;
+}
+export function writeFileStatsToFile(filestats, output_path) {
+    if (output_path == undefined) {
+        console.error("No stats output path provided");
+        return;
+    }
+    console.log("Writing file stats to: " + output_path);
+    const json = JSON.stringify(filestats, null, 2);
+    writeFileSync(output_path, json);
 }

package/dist/utils/version.js

@@ -3,12 +3,14 @@ let version = undefined;
 let isLocal = false;
 export function getVersion(marklocal = true) {
     if (version === undefined) {
+        console.log(process.argv);
         const scriptLocation = process.argv[1].replaceAll("\\", "/");
+        console.log("Determining version from " + scriptLocation);
         const path = scriptLocation.split('/');
         let packageJsonPath = null;
         while (path.length) {
             const dirname = path.join('/');
-            if (statSync(dirname || '/').isDirectory()) {
+            if (statSync(dirname).isDirectory()) {
                 const filename = dirname + '/package.json';
                 if (existsSync(filename)) {
                     packageJsonPath = filename;
@@ -27,6 +29,9 @@ export function getVersion(marklocal = true) {
             else
                 console.log("Could not find package.json at " + packageJsonPath);
         }
+        if (!version) {
+            throw new Error("Could not determine version");
+        }
     }
     let res = version;
     if (marklocal && isLocal)

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@needle-tools/gltf-build-pipeline",
-  "version": "1.6.0-alpha.1",
+  "version": "1.6.0-alpha.3",
   "description": "Pipeline and tools for optimizing gltf files using gltf-transform and compression settings within glTF extensions",
   "main": "index.mjs",
   "type": "module",
+  "readme": "README.md",
   "bin": {
     "gltf-build-pipeline": "./dist/cli/index.js"
   },

package/scripts/pack-gltf.mjs

@@ -79,6 +79,7 @@ async function packFile(file) {
         packedFiles,
         useCache: allowCaching,
         stats,
+        file_stats: null
     })
 }