@needle-tools/gltf-build-pipeline 2.6.0-alpha.1 → 2.7.0-alpha.1

package/CHANGELOG.md

@@ -4,6 +4,16 @@ 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.7.0-alpha.1] - 2024-01-13
+- fix: handle LOD omitting and remove deleted files from progressive transform results list
+
+## [2.7.0-alpha] - 2024-01-13
+- add: VRM mesh simplification support
+- fix: issue where the output directory was not created if it didn't exist yet 
+- fix: try resolve deduplicated meshes
+- change: update gltf-transform to 4.1.1
+- change: modify mesh LOD settings for more vertices
+
 ## [2.6.0-alpha] - 2024-12-16
 - add: create placeholder textures for missing jpg, png, webp, gif, tif on disc
 - fix: compressing a gltf file to a different output directory does not falsely delete old external textures on disc in the input directory

package/dist/extensions/NEEDLE_opaque/NEEDLE_opaque.js

@@ -1,4 +1,4 @@
-import { Extension, ExtensionProperty, PropertyType, TextureChannel } from '@gltf-transform/core';
+import { Extension, ExtensionProperty, PropertyType, Node, TextureChannel } from '@gltf-transform/core';
 import { getTexture, tryGetInArray, writeExtension } from '../utils.js';
 import { isLightmap } from '../../utils/texture.js';
 const ALL_PROPERTY_TYPES = [];
@@ -369,7 +369,7 @@ export function createOpaqueExtension(name, types, opts) {
                 writeExtension(result, EXTENSION_NAME, this.ext);
                 if (debugLog) {
                     // console.log("WRITE", EXTENSION_NAME, "to", this.gltfField, "at index", index);
-                    console.log(result);
+                    // console.log("WRITE RESULT", result);
                 }
             }
         }
@@ -646,6 +646,26 @@ class JsonPointerHandler {
                             pointer?.register(obj, key, fullPath);
                         }
                     }
+                    if (value.startsWith("/meshes/")) {
+                        if (this.debug)
+                            console.log("Read pointer", value);
+                        const index = parseInt(value.substring("/meshes/".length));
+                        const object = context.meshes[index];
+                        if (object) {
+                            let pointer = this.map.get(value);
+                            if (!pointer) {
+                                const definition = context.jsonDoc.json.meshes[index];
+                                const res = new MeshIndexResolver(this.document, object, definition, prop);
+                                res.debug = this.debug;
+                                res.init(context);
+                                pointer = new JsonPointer("/meshes/", res, value);
+                                pointer.debug = this.debug;
+                                this.map.set(value, pointer);
+                                prop.setReference(value, object);
+                            }
+                            pointer?.register(obj, key, fullPath);
+                        }
+                    }
                 }
                 break;
             case 'number':
@@ -770,14 +790,15 @@ class JsonPointer {
             else {
                 this.newPointer = index;
             }
-            if (this.debug)
-                console.log(`RESOLVED pointer ${this.oldPointer} to → ${this.newPointer}`);
             return true;
         }
         else {
             // If the pointer could not be resolved during write we need to log an error
-            if (step === "write")
-                console.log("ERR: 🧨 FAILED to resolve pointer", this.pointerBase, ` used by ${this._debugInfo.join(", ")}`);
+            if (step === "write") {
+                console.log(`ERR: 🧨 FAILED to resolve pointer \"${this.oldPointer}\" used by ${this._debugInfo.join(", ")}`);
+                if (this.debug)
+                    debugger;
+            }
         }
         return false;
     }
@@ -790,7 +811,7 @@ class JsonPointer {
             const obj = this._objects[i];
             const prop = this._props[i];
             if (this.debug) {
-                console.log(`< Resolved pointer ${this._debugInfo[i]}: ${this.newPointer}`);
+                console.log(`< Resolved pointer ${this._debugInfo[i]}: ${this.oldPointer} → ${this.newPointer}`);
             }
             obj[prop] = this.newPointer;
         }
@@ -802,10 +823,13 @@ class PointerResolver {
     inputObject;
     /* the original json definition */
     inputDefinition;
-    constructor(doc, obj, def) {
+    /** The graph property this pointer belongs to */
+    property;
+    constructor(doc, obj, def, prop) {
         this.document = doc;
         this.inputObject = obj;
         this.inputDefinition = def;
+        this.property = prop;
     }
     debug = false;
 }
@@ -913,3 +937,35 @@ class NodeIndexResolver extends PointerResolver {
         return context.nodeIndexMap.get(this.inputObject);
     }
 }
+class MeshIndexResolver extends PointerResolver {
+    init(context) {
+    }
+    resolve(context) {
+        let index = context.meshIndexMap.get(this.inputObject);
+        if (index >= 0) {
+            return index;
+        }
+        let obj = null;
+        if (this.inputObject.isDisposed()) {
+            // If the mesh was deduplicated we try to get the mesh from a parent node
+            // This is a HACK, we need to get the reference to the mesh this one was deduplicated with since the parent node potentially has many children
+            const parents = this.property?.listParents();
+            for (const parent of parents) {
+                if (parent instanceof Node) {
+                    obj = parent.getMesh();
+                    if (obj) {
+                        console.log(`INFO: resolved mesh \"${this.inputObject.getName()}\" from parent node \"${parent.getName()}\"`);
+                        break;
+                    }
+                }
+            }
+            if (obj.isDisposed()) {
+                console.warn("WARN: mesh is disposed", this.inputObject.getName());
+            }
+        }
+        if (!obj) {
+            return undefined;
+        }
+        return context.meshIndexMap.get(obj);
+    }
+}

package/dist/scripts/pack-gltf.js

@@ -81,10 +81,11 @@ export async function packGLTF(inputFile, outputFile, options) {
                 },
                 config,
             }),
-            needle_mesh_transform({ file: inputFile, config }, { ratio: 0.75, error: 0.0005 }),
+            needle_mesh_transform({ file: inputFile, config }),
             needle_animation_transform({}),
             resample(),
             // Can not dedup "materials" because progressive textures will then assigned to the wrong material instance
+            // HACK: keepUniqueNames is enabled to fix https://linear.app/needle/issue/NE-6288
             dedup({ propertyTypes: [PropertyType.MESH, PropertyType.MATERIAL] }),
             // prune(),
         ];
@@ -102,7 +103,7 @@ export async function packGLTF(inputFile, outputFile, options) {
             transforms.push(join({ keepNamed: false }));
         }
         await document.transform(...transforms);
-        logger.info(`⇄ Writing to ${outputFile}`);
+        logger.info(`← Writing to ${outputFile}`);
         await writeNodeIO(io, outputFile, document);
         if (useCache && cacheKey != undefined && existsSync(outputFile))
             addToCache(cacheKey, readFileSync(outputFile));

package/dist/transforms/needle_mesh_transform.d.ts

@@ -10,6 +10,6 @@ declare type MeshTransformContext = {
  * Which compression type for a model should be used. This should be respected when creating LOD meshes and the appropriate extension should be added to the LOD mesh so it receives the same mesh compression as the parent mesh
  */
 export declare function determineMeshCompression(document: Document, filePath: string): NEEDLE_mesh_compression_model_root;
-export declare const needle_mesh_transform: (context: MeshTransformContext, simplify: Omit<SimplifyOptions, "simplifier">) => Transform;
+export declare const needle_mesh_transform: (context: MeshTransformContext) => Transform;
 export declare function compressPrimitive(document: Document, mesh: Mesh, prim: Primitive, index: number, weldOptions: Required<WeldOptions>, meshOptions: Required<SimplifyOptions>): Promise<Primitive>;
 export {};

package/dist/transforms/needle_mesh_transform.js

@@ -3,6 +3,7 @@ import { meshopt, simplifyPrimitive, SIMPLIFY_DEFAULTS, WELD_DEFAULTS, draco } f
 import { MeshoptEncoder, MeshoptSimplifier } from "meshoptimizer";
 import { NEEDLE_mesh_compression, NEEDLE_mesh_compression_model_root } from "../extensions/index.js";
 import { weldPrimitive } from "../functions/weld.3.js";
+import { calculateMeshDensity } from "../utils/mesh.js";
 const NAME = 'needle_mesh_transform';
 /**
  * Which compression type for a model should be used. This should be respected when creating LOD meshes and the appropriate extension should be added to the LOD mesh so it receives the same mesh compression as the parent mesh
@@ -18,7 +19,7 @@ export function determineMeshCompression(document, filePath) {
             return rootModel;
         }
     }
-    if (filePath.endsWith(".vrm")) {
+    if (filePath?.toLowerCase().endsWith(".vrm")) {
         const hasBlendshapes = document.getRoot().listMeshes().some((mesh) => mesh.listPrimitives().some((prim) => prim.listTargets().length > 0));
         if (hasBlendshapes) {
             return new NEEDLE_mesh_compression_model_root("meshopt");
@@ -57,10 +58,10 @@ export function determineMeshCompression(document, filePath) {
     // }
     return new NEEDLE_mesh_compression_model_root("draco");
 }
-export const needle_mesh_transform = function (context, simplify) {
+export const needle_mesh_transform = function (context) {
     return async (document, _context) => {
         // TODO: needs to be moved into NEEDLE_progressive
-        await simplifierTransform(document, _context, simplify);
+        await simplifierTransform(document, _context, context);
         await applyMeshCompression(document, _context, context);
     };
 };
@@ -88,21 +89,28 @@ async function applyMeshCompression(document, transform_context, context) {
     document.getLogger().info(`[${NAME}]: → will apply draco mesh compression (default)`);
     return draco()(document, transform_context);
 }
-async function simplifierTransform(document, _context, _options) {
+async function simplifierTransform(document, _context, meshContext) {
     const simplifier = MeshoptSimplifier;
     if (!simplifier) {
         console.log(`WARN: [${NAME}] simplifier dependency required — install "meshoptimizer".`);
         return false;
     }
     const logger = document.getLogger();
-    const options = { ...SIMPLIFY_DEFAULTS, ..._options };
-    if (!options.simplifier)
-        options.simplifier = simplifier;
+    const isVRM = meshContext.file?.toLowerCase().endsWith(".vrm");
+    const options = {
+        ...SIMPLIFY_DEFAULTS,
+        simplifier: simplifier,
+        ratio: 0.75,
+        error: 0.0005,
+    };
     const weldOptions = {
         ...WELD_DEFAULTS,
-        tolerance: 0.00000000001,
         overwrite: true,
     };
+    // let meshInformation: MeshInformation | null = null;
+    // if (isVRM) {
+    //     meshInformation = getMeshInformation(document);
+    // }
     for (const mesh of document.getRoot().listMeshes()) {
         let i = 0;
         for (const prim of mesh.listPrimitives()) {
@@ -119,9 +127,25 @@ async function simplifierTransform(document, _context, _options) {
             const ext = prim.getExtension(NEEDLE_mesh_compression.EXTENSION_NAME);
             const mesh_compression = ext?.model;
             const simplifyOpts = { ...options };
-            if (!ext) {
+            if (isVRM) {
+                const density = calculateMeshDensity(prim);
+                if (density > 0) {
+                    const targetDensity = 2_000;
+                    const t = (1 / density) * targetDensity;
+                    simplifyOpts.ratio = Math.min(Math.max(.1, t), .95);
+                    simplifyOpts.error = 15 / density;
+                    simplifyOpts.lockBorder = true;
+                }
+                else {
+                    simplifyOpts.ratio = 0.8;
+                    simplifyOpts.error = 0.001;
+                    simplifyOpts.lockBorder = true;
+                }
+                logger.info(`${mesh.getName()}: Density: ${density.toFixed(2)}, Ratio: ${simplifyOpts.ratio.toFixed(2)}, Error: ${simplifyOpts.error}`);
+            }
+            if (!ext && !isVRM) {
                 // If no extension exists on the primitive dont apply any simplification
-                // console.log(`[${NAME}]: Skipping primitive simplification of mesh "${mesh.getName()}": No mesh compression extension found.`);
+                // AND if the file is not a VRM file
                 continue;
             }
             if (mesh_compression) {

package/dist/transforms/needle_progressive.js

@@ -9,7 +9,7 @@ import { addMetaToCache, addToCache, getHash, getKey, tryGetFromCache, tryGetMet
 import sharp from "sharp";
 import { detectTextureCompressionMode, ensureIsDirectory, foreachGLTF, generateGuid, getOutputPath, isLightmap, setLightmapName, ioTryReadWithMissingResources, validateImageMimeType, writeNodeIO } from '../utils/index.js';
 import { needle_asset, writeNeedleAsset } from './needle_asset.js';
-import { MeshoptDecoder, MeshoptSimplifier } from 'meshoptimizer';
+import { MeshoptDecoder, MeshoptEncoder, MeshoptSimplifier } from 'meshoptimizer';
 import { compressPrimitive, determineMeshCompression } from './needle_mesh_transform.js';
 import { calculateMeshDensity, getMeshInformation } from "../utils/mesh.js";
 export async function make_progressive(opts) {
@@ -29,6 +29,19 @@ export async function make_progressive(opts) {
         if (!res)
             success = false;
     });
+    if (success) {
+        // Make sure all results exist
+        // It's possible that files were deleted while omitting LODs - we want to remove them from the results list
+        const resultsCount = opts.results.length;
+        for (let i = opts.results.length - 1; i >= 0; i--) {
+            if (!existsSync(opts.results[i])) {
+                opts.results.splice(i, 1);
+            }
+        }
+        const resultsChanged = resultsCount !== opts.results.length;
+        if (opts.debug)
+            console.log(`Progressive Transform: ${opts.results.length} files processed. ${resultsChanged ? "Some results were removed" : ""}`);
+    }
     return success;
 }
 function registerExtensions(io) {
@@ -58,6 +71,7 @@ async function onProcess(file, opts) {
         registerExtensions(io);
         io.registerDependencies({
             'meshopt.decoder': MeshoptDecoder,
+            'meshopt.encoder': MeshoptEncoder,
             'draco3d.decoder': await draco3d.createDecoderModule(),
             'draco3d.encoder': await draco3d.createEncoderModule(),
         });
@@ -533,7 +547,7 @@ export function make_progressive_meshes(filePath, _options, opts) {
             // const t = l / MAX_LODS;
             const latest = LODS[LODS.length - 1];
             const ratio = latest.ratio * .5;
-            let error = Math.min(.013 * (l + 1), 0.05);
+            let error = Math.min(.013 * (l + 1), 0.003);
             if (opts.config.usecase === "product") {
                 error *= .5;
             }
@@ -544,6 +558,7 @@ export function make_progressive_meshes(filePath, _options, opts) {
                 // toleranceNormal: 0.1 + t * 0.1,
             });
         }
+        logger.debug(`[${NAME}]: Generating mesh LODs:\n${JSON.stringify(LODS, undefined, 2)}`);
         /** Map of visited GUID -> extension */
         const visited = new Map();
         const root = doc.getRoot();
@@ -659,7 +674,7 @@ export function make_progressive_meshes(filePath, _options, opts) {
                     if (shouldOmitLevel) {
                         logger.debug(`[${NAME}] Omitting LOD ${level} for \"${mesh.getName()}\" at \"${lodInfo.path}\"`);
                         generatedLODInfos.splice(i, 1);
-                        rmSync(fullPath);
+                        deleteFile(fullPath, opts);
                         i--;
                     }
                     else {
@@ -697,7 +712,7 @@ export function make_progressive_meshes(filePath, _options, opts) {
                 logger.info(`[${NAME}]: Flag mesh LOD ${generatedLODInfos.length} (embedded): vertex count difference below threshold (removed ${difference} vertices, ${(-diff01 * 100).toFixed(2)} %) → will remove all LODs. \"${mesh.getName()}\"`);
                 try {
                     for (const lodInfo of generatedLODInfos) {
-                        rmSync(outputDirectory + "/" + lodInfo.path);
+                        deleteFile(outputDirectory + "/" + lodInfo.path, opts);
                     }
                 }
                 catch (err) {
@@ -742,6 +757,9 @@ export function make_progressive_meshes(filePath, _options, opts) {
         }
     });
 }
+function deleteFile(filePath, _context) {
+    rmSync(filePath);
+}
 function clonePrimitiveData(prim, logger) {
     const semantics = prim.listSemantics();
     if (semantics.some(s => s.includes("JOINTS"))) {
@@ -842,6 +860,8 @@ async function createMeshLod(inputFileName, doc, basePath, level, mesh, meshInfo
                 const newAttr = newDoc.createAccessor();
                 newAttr.setArray(attr.getArray());
                 newAttr.setType(attr.getType());
+                newAttr.setSparse(attr.getSparse());
+                newAttr.setNormalized(attr.getNormalized());
                 newPrim.setAttribute(semantics[i], newAttr);
             }
             else {
@@ -853,20 +873,29 @@ async function createMeshLod(inputFileName, doc, basePath, level, mesh, meshInfo
             const newIndices = newDoc.createAccessor();
             newIndices.setArray(indices.getArray());
             newIndices.setType(indices.getType());
+            newIndices.setSparse(indices.getSparse());
+            newIndices.setNormalized(indices.getNormalized());
             newPrim.setIndices(newIndices);
         }
         const targets = prim.listTargets();
         for (const target of targets) {
             const newTarget = newDoc.createPrimitiveTarget(target.getName());
             newPrim.addTarget(newTarget);
-            for (const attr of target.listSemantics()) {
+            // const attributes = target.listAttributes();
+            const semantics = target.listSemantics();
+            for (const attr of semantics) {
                 const accessor = target.getAttribute(attr);
                 if (accessor) {
                     const newAccessor = newDoc.createAccessor();
                     newAccessor.setArray(accessor.getArray());
                     newAccessor.setType(accessor.getType());
+                    newAccessor.setSparse(accessor.getSparse());
+                    newAccessor.setNormalized(accessor.getNormalized());
                     newTarget.setAttribute(attr, newAccessor);
                 }
+                else {
+                    console.error(`[${NAME}] Missing target attribute ${attr} in mesh LOD ${level}`);
+                }
             }
         }
         ;

package/dist/utils/mesh.d.ts

@@ -1,10 +1,10 @@
-import { Mesh, Primitive } from "@gltf-transform/core";
+import { Document, Mesh, Primitive } from "@gltf-transform/core";
 export declare type MeshInformation = {
     readonly maxVertexCount: number;
     readonly totalVertexCount: number;
     readonly totalIndexCount: number;
 };
-export declare function getMeshInformation(mesh: Mesh): MeshInformation;
+export declare function getMeshInformation(mesh: Mesh | Document): MeshInformation;
 /**
  * Calculate the density of a mesh.
  * @param prim - The primitive to calculate the density for.

package/dist/utils/mesh.js

@@ -1,18 +1,35 @@
+import { Mesh } from "@gltf-transform/core";
 export function getMeshInformation(mesh) {
     let maxVertexCount = 0;
     let totalIndexCount = 0;
-    const totalVertexCount = mesh.listPrimitives().reduce((acc, prim) => {
-        const indices = prim.getIndices()?.getCount() || 0;
-        totalIndexCount += indices;
-        const vertices = prim.getAttribute('POSITION')?.getCount() || 0;
-        maxVertexCount = Math.max(maxVertexCount, vertices);
-        return acc + vertices;
-    }, 0);
-    return {
-        maxVertexCount,
-        totalVertexCount,
-        totalIndexCount,
-    };
+    let totalVertexCount = 0;
+    if (mesh instanceof Mesh) {
+        totalVertexCount = mesh.listPrimitives().reduce((acc, prim) => {
+            const indices = prim.getIndices()?.getCount() || 0;
+            totalIndexCount += indices;
+            const vertices = prim.getAttribute('POSITION')?.getCount() || 0;
+            maxVertexCount = Math.max(maxVertexCount, vertices);
+            return acc + vertices;
+        }, 0);
+        return {
+            maxVertexCount,
+            totalVertexCount,
+            totalIndexCount,
+        };
+    }
+    else {
+        mesh.getRoot().listMeshes().forEach(mesh => {
+            const info = getMeshInformation(mesh);
+            maxVertexCount = Math.max(maxVertexCount, info.maxVertexCount);
+            totalVertexCount += info.totalVertexCount;
+            totalIndexCount += info.totalIndexCount;
+        });
+        return {
+            maxVertexCount,
+            totalVertexCount,
+            totalIndexCount,
+        };
+    }
 }
 /**
  * Calculate the density of a mesh.

package/dist/utils/nodeio.js

@@ -1,9 +1,15 @@
+import { existsSync, mkdirSync } from "fs";
 import { writeFile } from "fs/promises";
+import path from "path";
 import sharp from "sharp";
 /**
  * Handle writing glTf, GLB and VRM files
  */
 export async function writeNodeIO(nodeio, filename, document) {
+    const directoryPath = path.dirname(filename);
+    if (!existsSync(directoryPath)) {
+        mkdirSync(directoryPath);
+    }
     // see https://github.com/donmccurdy/glTF-Transform/issues/1390
     if (filename.endsWith(".vrm")) {
         const bin = await nodeio.writeBinary(document);

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

@@ -0,0 +1 @@
+export declare const version = "2.7.0-alpha.1";

package/dist/utils/version.gen.js

@@ -0,0 +1 @@
+export const version = "2.7.0-alpha.1";

package/dist/utils/version.js

@@ -1,5 +1,4 @@
-import packageJson from "#package.json" assert { type: "json" };
+import { version } from './version.gen.js';
 export function getVersion(_marklocal = true) {
-    let res = packageJson.version;
-    return res;
+    return version;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@needle-tools/gltf-build-pipeline",
-  "version": "2.6.0-alpha.1",
+  "version": "2.7.0-alpha.1",
   "description": "Pipeline and tools for optimizing gltf files using gltf-transform and compression settings within glTF extensions",
   "main": "dist/index.js",
   "type": "module",
@@ -47,9 +47,9 @@
   },
   "dependencies": {
     "@donmccurdy/caporal": "~0.0.10",
-    "@gltf-transform/core": "^4.0.8",
-    "@gltf-transform/extensions": "^4.0.8",
-    "@gltf-transform/functions": "^4.0.8",
+    "@gltf-transform/core": "^4.1.1",
+    "@gltf-transform/extensions": "^4.1.1",
+    "@gltf-transform/functions": "^4.1.1",
     "command-exists": "^1.2.9",
     "command-line-args": "^5.2.1",
     "draco3dgltf": "^1.5.3",