@needle-tools/gltf-build-pipeline 1.4.8 → 1.4.10

package/CHANGELOG.md

@@ -4,6 +4,13 @@ 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.4.10] - 2023-04-23
+- add: NEEDLE_progressive can now load and process already draco compressed meshes
+
+## [1.4.9] - 2023-04-23
+- add: NEEDLE_progressive now have `hash` field for LODs which is generated using the content of the LOD and it's settings that produced it.  
+- fix: NEEDLE_progressive catches error when copying mesh with extensions where the copy operation fails
+
 ## [1.4.8] - 2023-04-22
 - fix: update sharp package to `^0.32.6`
 - change: NEEDLE_progressive meshes max LOD error increased

package/dist/cache/cache.d.ts

@@ -39,6 +39,10 @@ export declare function tryGetMetaFromCache(key: string, ignoreVersion?: boolean
  * @returns The key as a string.
  */
 export declare function getKey(property: ExtensibleProperty): string;
+export declare function getKeyWithHash(property: ExtensibleProperty): {
+    key: string;
+    hash: number;
+};
 /**
  * Get the hash for a property or an object.
  * @param property The property to get the hash for.

package/dist/cache/cache.js

@@ -139,6 +139,15 @@ export function getKey(property) {
     const key = `${prefix}-${hash}`;
     return key;
 }
+export function getKeyWithHash(property) {
+    let prefix = "prop";
+    if (property instanceof Texture) {
+        prefix = "image";
+    }
+    let hash = getHash(property);
+    const key = `${prefix}-${hash}`;
+    return { key, hash };
+}
 /**
  * Get the hash for a property or an object.
  * @param property The property to get the hash for.

package/dist/extensions/NEEDLE_progressive/NEEDLE_progressive.d.ts

@@ -7,14 +7,19 @@ export type ProgressiveLoadingInfo = {
     lods?: Array<LodInfo>;
 };
 type LodInfo = {
+    /** Relative path to the LOD file */
     path: string;
+    /**  Hash of the LOD file. It has been generated using the file content and settings */
+    hash: string;
 };
 export type ProgressiveTextureModel = ProgressiveLoadingInfo & {
     lods?: Array<LodInfo & {}>;
 };
 export type ProgressiveMeshModel = ProgressiveLoadingInfo & {
+    /** LOD0 vertex density. TODO: remove this since we now have a LODs array. This is just for supporting older engine versions */
     density: number;
     lods?: Array<LodInfo & {
+        /** Mesh vertex density */
         density: number;
         vertexCount: number;
         indexCount: number;

package/dist/transforms/needle_progressive.js

@@ -1,10 +1,11 @@
 import { BufferUtils, Document, NodeIO, PropertyType } from '@gltf-transform/core';
 import { SIMPLIFY_DEFAULTS, WELD_DEFAULTS, listTextureSlots, sparse } from '@gltf-transform/functions';
+import draco3d from 'draco3dgltf';
 import { NEEDLE_PROGRESSIVE_EXTENSION_NAME, NEEDLE_progressive } from "../extensions/NEEDLE_progressive/index.js";
 import { createOpaqueExtension, currentGenerator, NEEDLE_compression_texture, NEEDLE_mesh_compression, NEEDLE_progressive_mesh_settings, NEEDLE_progressive_texture_settings, registerExtensions as registerDefaultExtensions } from '../extensions/index.js';
 import path, { basename } from 'path';
 import { existsSync, readFileSync, rmSync, statSync, writeFileSync } from 'fs';
-import { addMetaToCache, addToCache, getHash, getKey, tryGetFromCache, tryGetMetaFromCache } from '../cache/index.js';
+import { addMetaToCache, addToCache, getHash, getKeyWithHash, tryGetFromCache, tryGetMetaFromCache } from '../cache/index.js';
 import sharp from "sharp";
 import { foreachGLTF, generateGuid } from '../utils/index.js';
 import { needle_asset, writeNeedleAsset } from './needle_asset.js';
@@ -49,6 +50,8 @@ async function process(file, opts) {
         registerExtensions(io);
         io.registerDependencies({
             'meshopt.decoder': MeshoptDecoder,
+            'draco3d.decoder': await draco3d.createDecoderModule(),
+            'draco3d.encoder': await draco3d.createEncoderModule(),
         });
         const document = await io.read(file).catch((err) => {
             // Log this message as a warning, it happens when trying to run on a already compressed gltf file (e.g. pre-processed. When logging an error we fail the build which is not desired)
@@ -159,12 +162,14 @@ export function make_progressive_textures(filePath, _options = TEXTURE_RESIZE_DE
             if (!outPath) {
                 continue;
             }
+            const { key, hash } = getKeyWithHash(texture);
             const relName = path.relative(directory, outPath);
             // TODO: this path should be added to the NEEDLE dependencies extension
             const model = {
                 guid: textureGuid,
                 lods: [
                     {
+                        hash: hash.toString(),
                         path: relName,
                     }
                 ],
@@ -172,7 +177,6 @@ export function make_progressive_textures(filePath, _options = TEXTURE_RESIZE_DE
             // for backwards compatibility - this should be removed in the future
             model["uri"] = relName;
             texture.setExtension(NEEDLE_PROGRESSIVE_EXTENSION_NAME, progressiveExt.createTexture(model));
-            const key = getKey(texture);
             if (opts.useCache) {
                 const cached = tryGetFromCache(key);
                 if (cached) {
@@ -526,6 +530,7 @@ export function make_progressive_meshes(filePath, _options, opts) {
                     lods: generatedLODInfos.map(l => {
                         return {
                             path: l.path,
+                            hash: l.content_hash.toString(),
                             density: l.density,
                             vertexCount: l.lodMeshInfo?.totalVertexCount,
                             indexCount: l.lodMeshInfo?.totalIndexCount,
@@ -587,21 +592,21 @@ async function createMeshLod(doc, basePath, level, mesh, meshInfo, guid, lodLeve
     const outPath = basePath + fileName;
     const primitives = mesh.listPrimitives();
     let cacheKey = undefined;
+    // generate hash for mesh
+    let hash = mesh["needle:mesh-hash"];
+    if (hash === undefined) {
+        hash = getHash(mesh);
+        mesh["needle:mesh-hash"] = hash;
+    }
+    hash += getHash(lodLevel);
     if (opts.useCache !== false) {
-        // generate hash for mesh
-        let hash = mesh["needle:mesh-hash"];
-        if (hash === undefined) {
-            hash = getHash(mesh);
-            mesh["needle:mesh-hash"] = hash;
-        }
-        hash += getHash(lodLevel);
         cacheKey = `mesh_lod_${level}_${hash}`;
         const cachedValue = tryGetFromCache(cacheKey);
         const meta = tryGetMetaFromCache(cacheKey);
         if (cachedValue && meta) {
             console.log(`[${NAME}] LOD ${level} loaded ${(cachedValue.length / 1024).toFixed()} KB from cache for \"${mesh.getName()}\"`);
             writeFileSync(outPath, cachedValue);
-            return { level, path: fileName, success: true, cacheKey: cacheKey, lodMeshInfo: meta.meshInfo, density: meta.density };
+            return { level, path: fileName, success: true, cacheKey: cacheKey, content_hash: hash, lodMeshInfo: meta.meshInfo, density: meta.density };
         }
     }
     const newDoc = new Document();
@@ -667,9 +672,14 @@ async function createMeshLod(doc, basePath, level, mesh, meshInfo, guid, lodLeve
         for (const ext of extensions) {
             const PropertyClass = ext.constructor;
             const newProp = new PropertyClass(newDoc.getGraph());
-            const copy = newProp.copy(ext);
-            const name = ext.extensionName;
-            newPrim.setExtension(name, copy);
+            try {
+                const copy = newProp.copy(ext);
+                const name = ext.extensionName;
+                newPrim.setExtension(name, copy);
+            }
+            catch (err) {
+                console.error(`WARN: [${NAME}] Failed to copy extension ${ext.extensionName} for mesh LOD ${level} → ${err}`);
+            }
         }
     }
     let primitiveIndex = 0;
@@ -687,7 +697,7 @@ async function createMeshLod(doc, basePath, level, mesh, meshInfo, guid, lodLeve
     const newMeshInformation = getMeshInformation(newMesh);
     if (newMeshInformation.totalVertexCount < 4) {
         console.error(`[${NAME}] mesh LOD ${level} is has less than 4 vertices → skipping`);
-        return { level, path: fileName, success: false, cacheKey: cacheKey, lodMeshInfo: null, density: null, };
+        return { level, path: fileName, success: false, cacheKey: cacheKey, content_hash: hash, lodMeshInfo: null, density: null, };
     }
     let density = 0;
     for (const prim of newMesh.listPrimitives()) {
@@ -723,7 +733,7 @@ async function createMeshLod(doc, basePath, level, mesh, meshInfo, guid, lodLeve
         addToCache(cacheKey, bytes);
         addMetaToCache(cacheKey, { meshInfo: newMeshInformation, density: density });
     }
-    return { level, path: fileName, success: true, lodMeshInfo: newMeshInformation, cacheKey: cacheKey, density: density };
+    return { level, path: fileName, success: true, lodMeshInfo: newMeshInformation, cacheKey: cacheKey, content_hash: hash, density: density };
 }
 async function simplifyMesh(doc, mesh, prim, index, lodinfo) {
     const weldOptions = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@needle-tools/gltf-build-pipeline",
-  "version": "1.4.8",
+  "version": "1.4.10",
   "description": "Pipeline and tools for optimizing gltf files using gltf-transform and compression settings within glTF extensions",
   "main": "index.mjs",
   "type": "module",