@needle-tools/gltf-build-pipeline 2.14.0 → 2.15.0-next.a25e7ea

package/dist/cache/cache.js

@@ -5,9 +5,9 @@ import path from 'path';
 import { getVersion } from "../utils/version.js";
 // import * as CHECKDISCSPACE from 'check-disk-space'
 import xxhash from "xxhash-wasm";
-let hasher = null;
+let xxHashModule = null;
 xxhash().then(module => {
-    hasher = module.create32();
+    xxHashModule = module;
 });
 /**
  * Get the available space on the cache directory in bytes.
@@ -304,9 +304,9 @@ function hashObject(obj, depth = 0) {
     }
 }
 function hashBuffer(buffer, offset, length) {
-    if (hasher) {
+    if (xxHashModule) {
         const view = new Uint8Array(buffer, offset, length);
-        return hasher.update(view).digest();
+        return xxHashModule.h32Raw(view);
     }
     let hash = 0;
     const view = new Uint8Array(buffer, offset, length);

package/dist/extensions/NEEDLE_opaque/NEEDLE_opaque.js

@@ -1,6 +1,7 @@
 import { Extension, ExtensionProperty, PropertyType, Node, TextureChannel } from '@gltf-transform/core';
 import { getTexture, tryGetInArray, writeExtension } from '../utils.js';
 import { isLightmap } from '../../utils/texture.js';
+import { NEEDLE_progressive_texture_settings } from '../NEEDLE_progressive_texture_settings/index.js';
 const ALL_PROPERTY_TYPES = [];
 for (const key in PropertyType) {
     ALL_PROPERTY_TYPES.push(PropertyType[key]);
@@ -123,8 +124,11 @@ export function createOpaqueExtension(name, types, opts) {
                             const prop = this.createExtension();
                             this.jsonPointerHandler.read(context, texture, ext, prop);
                             texture.setExtension(EXTENSION_NAME, prop);
-                            const handler = new TextureHandler(this.document, textureDefinition, EXTENSION_NAME, ext, debugLog);
+                            const handler = new TextureHandler(this.document, textureDefinition, EXTENSION_NAME, ext, debugLog, texture);
                             prop.add(handler);
+                            const sourceIndex = textureDefinition.source;
+                            if (debugLog)
+                                console.log("Found texture with extension", EXTENSION_NAME, "at index", index, "source image index", sourceIndex, "name", texture.getName() || "<unnamed>");
                         });
                         break;
                     case PropertyType.NODE:
@@ -188,11 +192,11 @@ export function createOpaqueExtension(name, types, opts) {
             const textures = this.document.getRoot().listTextures();
             for (let i = 0; i < textures.length; i++) {
                 const tex = textures[i];
-                const texDef = textureDefinitions[i];
-                const name = texDef?.name;
                 if (isLightmap(tex) && tex.getMimeType() !== "image/exr") {
                     prop.setReference("lightmapTexture", tex, { channels: TextureChannel.R | TextureChannel.G | TextureChannel.B | TextureChannel.A });
-                    logger.info(`Found lightmap texture ${name}: ${tex.getMimeType()} in ${EXTENSION_NAME}`);
+                    const texDef = textureDefinitions[i]; // @TODO: textureDefinitions and textures might not be in the same order - we need to find the texture by source index instead of assuming the order is the same
+                    const name = tex.getName() || texDef?.name;
+                    logger.info(`Found lightmap texture \"${name}\" (${tex.getMimeType()}) in ${EXTENSION_NAME}`);
                 }
             }
         }
@@ -389,30 +393,38 @@ class GenericWriter {
 class TextureHandler {
     document;
     textureDefinition;
-    index;
     key;
     ext;
     debug = false;
+    /** Reference to the gltf-transform Texture object, used to resolve the current image index at write time via imageIndexMap */
+    textureRef;
     assignTo(obj) {
         Object.assign(obj, this.ext);
     }
-    constructor(doc, def, key, ext, debug) {
+    constructor(doc, def, key, ext, debug, textureRef) {
         this.document = doc;
         this.textureDefinition = def;
         this.key = key;
         this.ext = ext;
         this.debug = debug;
-        this.index = this.tryGetSourceIndex(this.textureDefinition);
-        if (debug)
-            console.log(def);
+        this.textureRef = textureRef;
+        if (debug) {
+            const index = this.tryGetSourceIndex(this.textureDefinition);
+            console.log(index, this.textureDefinition);
+        }
     }
     write(ctx) {
-        let foundTexture = false;
-        const textureDefs = ctx.jsonDoc.json.textures || [];
-        const imageIndex = this.index !== undefined ? this.index : this.tryGetSourceIndex(this.textureDefinition);
+        // Resolve the current image index from the gltf-transform graph reference.
+        // This is stable even after dedup/prune operations that re-index images.
+        const imageIndex = ctx.imageIndexMap.get(this.textureRef);
         if (imageIndex === undefined) {
-            console.warn("WARN: no source index found for texture", this.key);
+            if (this.key !== "EXT_texture_exr" && this.debug) {
+                console.warn("WARN: failed to resolve image index for texture via imageIndexMap:", this.key, this.textureRef.getName() || "<unnamed>");
+            }
+            return;
         }
+        let foundTexture = false;
+        const textureDefs = ctx.jsonDoc.json.textures || [];
         textureDefs?.forEach((textureDef, i) => {
             if (foundTexture)
                 return;
@@ -432,17 +444,10 @@ class TextureHandler {
             }
         });
         if (foundTexture === false) {
-            if (this.key !== "EXT_texture_exr" && this.debug)
-                console.warn("WARN: failed to re-assign extension:", this.key, this.index, this.tryGetSourceIndex(this.textureDefinition), textureDefs.length);
-        }
-        // this.document
-        //     .getRoot()
-        //     .listTextures()
-        //     .forEach((texture, index) => {
-        //         if (foundTexture) return;
-        //         if (!texture.getExtension(this.key)) return;
-        //         const imageIndex = ctx.imageIndexMap.get(texture);
-        //     });
+            if (this.key !== "EXT_texture_exr" && this.debug) {
+                console.warn("WARN: failed to re-assign extension:", this.key, "imageIndex", imageIndex, textureDefs.length, this.textureRef.getName() || "<unnamed>", this.textureDefinition);
+            }
+        }
     }
     tryGetSourceIndex(def) {
         let index = def.source;
@@ -878,11 +883,18 @@ class TextureIndexResolver extends PointerResolver {
         // create a new texture def entry
         if (this.debug)
             console.log("Could not find texture, creating a new one: " + this._debugName);
-        const hasExtensionWithSource = this.inputDefinition.extensions && Object.keys(this.inputDefinition.extensions).some(key => this.inputDefinition.extensions[key]["source"] !== undefined);
+        // Remove settings-only extensions that are consumed during processing and should not appear in the output.
+        let extensions = this.inputDefinition.extensions ? { ...this.inputDefinition.extensions } : undefined;
+        if (extensions) {
+            delete extensions[NEEDLE_progressive_texture_settings.EXTENSION_NAME];
+            if (Object.keys(extensions).length === 0)
+                extensions = undefined;
+        }
+        const hasExtensionWithSource = extensions && Object.keys(extensions).some(key => extensions[key]?.["source"] !== undefined);
         const textureDef = {
             source: hasExtensionWithSource ? undefined : imgIndex,
             sampler: this.findOrCreateSampler(context.jsonDoc.json),
-            extensions: this.inputDefinition.extensions,
+            extensions: extensions,
             extras: this.inputDefinition.extras,
         };
         context.jsonDoc.json.textures.push(textureDef);

package/dist/scripts/pack-gltf.js

@@ -128,7 +128,8 @@ export async function packGLTF(inputFile, outputFile, options) {
         return true;
     }
     catch (err) {
-        logger.error(`Packing of "${path.basename(inputFile)}" using version ${getVersion()} failed with error:\n${err.message}`);
+        const shortedStackTrace = err instanceof Error && err.stack ? err.stack.split('\n').slice(0, 2).join('\n') : '';
+        logger.error(`Packing of "${path.basename(inputFile)}" using version ${getVersion()} failed with error:\n${err.message}\n${shortedStackTrace}`);
         if (debug)
             throw err;
         return false;

package/dist/transforms/needle_progressive.js

@@ -151,6 +151,7 @@ export function make_progressive_textures(filePath, _options = TEXTURE_RESIZE_DE
             return Promise.resolve();
         }
         let index = 0;
+        const textureHashCache = new Map();
         for (const texture of doc.getRoot().listTextures()) {
             const textureIndex = index++;
             const name = texture.getName();
@@ -177,8 +178,10 @@ export function make_progressive_textures(filePath, _options = TEXTURE_RESIZE_DE
                     continue;
                 }
                 else {
+                    if (!textureHashCache.has(texture))
+                        textureHashCache.set(texture, getHash(texture));
                     settings = {
-                        guid: generateGuid(filename + "_texture_" + index.toString()),
+                        guid: generateGuid(textureHashCache.get(texture)),
                         maxSize: _options.size[0],
                     };
                     logger.debug(`[${NAME}] No settings found for texture[${index}] - will use default settings (maxSize: ${settings.maxSize}, guid: ${settings.guid})`);
@@ -213,7 +216,13 @@ export function make_progressive_textures(filePath, _options = TEXTURE_RESIZE_DE
                 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());
+            if (!settings.guid?.length) {
+                if (!textureHashCache.has(texture))
+                    textureHashCache.set(texture, getHash(texture));
+                const hash = textureHashCache.get(texture);
+                settings.guid = generateGuid(hash);
+            }
+            const textureGuid = settings.guid;
             /** This is the size of the texture that is embedded in the glTF. No LOD should be smaller than this */
             const maxSize = settings.maxSize;
             const LOD_LEVEL = new Array();
@@ -524,7 +533,7 @@ async function resizeTexture(options, texture, logger, uri, slots) {
     }
     dstWidth = Math.floor(dstWidth);
     dstHeight = Math.floor(dstHeight);
-    logger.info(`→ Resize texture (${uri || texture.getName() || slots.join(", ")}) from ${srcWidth}x${srcHeight} to ${dstWidth}x${dstHeight}px`);
+    logger.info(`→ Resize texture (${uri || texture.getName() || slots?.join(", ")}) from ${srcWidth}x${srcHeight} to ${dstWidth}x${dstHeight}px`);
     // https://sharp.pixelplumbing.com/api-resize
     const buffer = await sharp(texture.getImage())
         .resize(dstWidth, dstHeight, {

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

@@ -1 +1 @@
-export declare const version = "2.14.0";
+export declare const version = "2.15.0-next.a25e7ea";

package/dist/utils/version.gen.js

@@ -1 +1 @@
-export const version = "2.14.0";
+export const version = "2.15.0-next.a25e7ea";

package/package.json

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