@needle-tools/gltf-build-pipeline 2.8.0-alpha.2 → 2.8.1-alpha.1

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.8.1-alpha.0] - 2024-03-26
+- Fix: Issue where cache key gets longer depending on the primitive count
+- Fix: Cache key not taking index buffer into account
+- Fix: Caching of mesh LODs did clone shared mesh attributes for every primitive instead of re-using previous clones
+
 ## [2.8.0-alpha.2] - 2024-03-04
 - change: use webp compression for textures smaller than 32x32
 - fix: webp compression for small textures (64x64)

package/dist/cache/cache.js

@@ -202,8 +202,9 @@ export function getHash(property, level = 0) {
             const weights = property.getWeights();
             hash += hashObject(weights);
             const primitives = property.listPrimitives();
-            for (const prim of primitives)
-                hashStr += getHash(prim, level + 1);
+            for (const prim of primitives) {
+                hash += hashString(getHash(prim, level + 1));
+            }
         }
         else if (property instanceof Primitive) {
             const indices = property.getIndices();
@@ -222,11 +223,19 @@ export function getHash(property, level = 0) {
                 targets,
                 semantics: semanticsNames
             });
+            if (indices) {
+                const indexBuffer = indices.getArray();
+                if (indexBuffer) {
+                    hash += hashBuffer(indexBuffer.buffer, indexBuffer.byteOffset, indexBuffer.byteLength);
+                }
+            }
             // We can not pass the whole buffer into hashObject since very large meshes will cause errors when trying to stringify
             // See https://linear.app/needle/issue/NE-6414
             for (const sem of semantics) {
-                const arr = property.getAttribute(sem).getArray();
-                hash += hashBuffer(arr.buffer, arr.byteOffset, arr.byteLength);
+                const arr = property.getAttribute(sem)?.getArray();
+                if (arr) {
+                    hash += hashBuffer(arr.buffer, arr.byteOffset, arr.byteLength);
+                }
             }
         }
     }

package/dist/transforms/needle_mesh_transform.js

@@ -4,6 +4,7 @@ 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";
+import { isMeshLOD } from "./needle_progressive.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
@@ -66,6 +67,7 @@ export const needle_mesh_transform = function (context) {
     };
 };
 async function applyMeshCompression(document, transform_context, context) {
+    const isLOD = isMeshLOD(context.file);
     const compressionModel = determineMeshCompression(document, context.file); // document.getRoot().getExtension(NEEDLE_mesh_compression.EXTENSION_NAME) as NEEDLE_mesh_compression_property;
     if (compressionModel) {
         // const rootModel = rootExtension.model as NEEDLE_mesh_compression_model_root;
@@ -76,7 +78,9 @@ async function applyMeshCompression(document, transform_context, context) {
             }
             document.getLogger().info(`[${NAME}]: ${compressionModel.compression.toUpperCase()} → will apply ${compressionModel.compression} mesh compression`);
             if (compressionModel.compression === "draco") {
-                const transform = draco();
+                const transform = draco({
+                    quantizationVolume: isLOD ? "scene" : undefined
+                });
                 return transform(document, transform_context);
             }
             else if (compressionModel.compression === "meshopt") {
@@ -87,7 +91,10 @@ async function applyMeshCompression(document, transform_context, context) {
     }
     // by default we still want to run draco if the root doesnt have a compression model configured
     document.getLogger().info(`[${NAME}]: → will apply draco mesh compression (default)`);
-    return draco()(document, transform_context);
+    const transform = draco({
+        quantizationVolume: isLOD ? "scene" : undefined
+    });
+    return transform(document, transform_context);
 }
 async function simplifierTransform(document, _context, meshContext) {
     const simplifier = MeshoptSimplifier;

package/dist/transforms/needle_progressive.js

@@ -660,7 +660,7 @@ export function make_progressive_meshes(filePath, _options, opts) {
                             const vertexDifference = lastMeshInfo.totalVertexCount - meshInfo.totalVertexCount;
                             const diff01 = vertexDifference / lastMeshInfo.totalVertexCount;
                             if (vertexDifference < 0) {
-                                console.log(`WARN: ❌ [${NAME}] Flag mesh LOD ${level}: vertex count did increase (${-vertexDifference.toFixed(0)} vertices, ${(-diff01 * 100).toFixed(4)}%) → LOD ${level} will be omitted. \"${mesh.getName()}\" at \"${lodInfo.path}\" ${JSON.stringify(lastMeshInfo)} → ${JSON.stringify(meshInfo)}`);
+                                console.log(`WARN: [${NAME}] Flag mesh LOD ${level}: vertex count did increase (${-vertexDifference.toFixed(0)} vertices, ${(-diff01 * 100).toFixed(4)}%) → LOD ${level} will be omitted. \"${mesh.getName()}\" at \"${lodInfo.path}\" ${JSON.stringify(lastMeshInfo)} → ${JSON.stringify(meshInfo)}`);
                                 shouldOmitLevel = true;
                             }
                             else if (vertexDifference < 32 || diff01 < 0.05) {
@@ -850,27 +850,13 @@ async function createMeshLod(inputFileName, doc, basePath, level, mesh, meshInfo
     }
     const tasks = new Array();
     // let didRunSimplification = false;
+    const clonedAttributes = new Map();
     for (const prim of primitives) {
         const newPrim = newDoc.createPrimitive();
         newMesh.addPrimitive(newPrim);
         newPrim.setName(prim.getName());
         newPrim.setMode(prim.getMode());
         newPrim.setMaterial(newMat);
-        const semantics = prim.listSemantics();
-        for (let i = 0; i < semantics.length; i++) {
-            const attr = prim.getAttribute(semantics[i]);
-            if (attr) {
-                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 {
-                logger.warn(`[${NAME}] Missing attribute ${semantics[i]} in mesh LOD ${level}`);
-            }
-        }
         const indices = prim.getIndices();
         if (indices) {
             const newIndices = newDoc.createAccessor();
@@ -880,6 +866,28 @@ async function createMeshLod(inputFileName, doc, basePath, level, mesh, meshInfo
             newIndices.setNormalized(indices.getNormalized());
             newPrim.setIndices(newIndices);
         }
+        const semantics = prim.listSemantics();
+        for (let i = 0; i < semantics.length; i++) {
+            const attr = prim.getAttribute(semantics[i]);
+            if (attr) {
+                if (clonedAttributes.has(attr)) {
+                    const cloned = clonedAttributes.get(attr);
+                    newPrim.setAttribute(semantics[i], cloned);
+                }
+                else {
+                    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);
+                    clonedAttributes.set(attr, newAttr);
+                }
+            }
+            else {
+                logger.warn(`[${NAME}] Missing attribute ${semantics[i]} in mesh LOD ${level}`);
+            }
+        }
         const targets = prim.listTargets();
         for (const target of targets) {
             const newTarget = newDoc.createPrimitiveTarget(target.getName());
@@ -964,7 +972,8 @@ async function createMeshLod(inputFileName, doc, basePath, level, mesh, meshInfo
     // add to cache
     if (cacheKey != undefined) {
         const bytes = readFileSync(outPath);
-        logger.info(`[${NAME}] Add LOD ${level} to cache for \"${mesh.getName()}\" as ${cacheKey}`);
+        const sizeInMB = (bytes.byteLength / 1024 / 1024).toFixed(2);
+        logger.info(`[${NAME}] Add LOD ${level} to cache (${sizeInMB} MB) for \"${mesh.getName()}\" as ${cacheKey}`);
         addToCache(cacheKey, bytes);
         addMetaToCache(cacheKey, { meshInfo: newMeshInformation, density: density });
     }

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

@@ -1 +1 @@
-export declare const version = "2.8.0-alpha.2";
+export declare const version = "2.8.1-alpha.1";

package/dist/utils/version.gen.js

@@ -1 +1 @@
-export const version = "2.8.0-alpha.2";
+export const version = "2.8.1-alpha.1";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@needle-tools/gltf-build-pipeline",
-  "version": "2.8.0-alpha.2",
+  "version": "2.8.1-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",