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

package/dist/cache/cache.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
 import { ExtensibleProperty } from "@gltf-transform/core";
 import { Logger } from "@donmccurdy/caporal";
 /**

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,8 @@
 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';
+import { testAssert } from '../../utils/test-assert.js';
 const ALL_PROPERTY_TYPES = [];
 for (const key in PropertyType) {
     ALL_PROPERTY_TYPES.push(PropertyType[key]);
@@ -123,8 +125,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 +193,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,39 +394,52 @@ 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);
+        // If the texture was converted (e.g. EXR → KTX2 via PMREM), skip writing the old extension
+        if (this.key === "EXT_texture_exr" && this.textureRef.getMimeType() !== "image/exr") {
+            return;
+        }
+        // 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);
+        testAssert(imageIndex !== undefined || this.key === "EXT_texture_exr", `imageIndexMap missing texture ref for "${this.key}": ${this.textureRef.getName() || "<unnamed>"}`);
         if (imageIndex === undefined) {
-            console.warn("WARN: no source index found for texture", this.key);
+            if (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;
             const textureImageIndex = this.tryGetSourceIndex(textureDef);
             if (imageIndex === textureImageIndex) {
-                if (!textureDef.extensions || !textureDef.extensions[this.key]) {
-                    // assign texture extension again
+                foundTexture = true;
+                if (!textureDef.extensions?.[this.key]) {
+                    // assign texture extension
                     textureDef.extensions = textureDef.extensions || {};
-                    foundTexture = true;
                     if (this.debug)
                         console.log("Re-Assign extension:", this.key, "at", i);
                     const newExt = { ...this.ext };
@@ -429,20 +447,16 @@ class TextureHandler {
                         newExt.source = imageIndex;
                     textureDef.extensions[this.key] = newExt;
                 }
+                // else: extension already written by another handler for the same image
+                // (happens when gltf-transform dedup merges texture defs that shared the same source)
             }
         });
+        testAssert(foundTexture || this.key === "EXT_texture_exr", `failed to match texture for extension "${this.key}", imageIndex=${imageIndex}, textures=${textureDefs.length}, name=${this.textureRef.getName() || "<unnamed>"}, type=${this.textureRef.getMimeType()}`);
         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.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;
@@ -857,7 +871,8 @@ class TextureIndexResolver extends PointerResolver {
     resolve(context) {
         const imgIndex = context.imageIndexMap.get(this.inputObject);
         if (imgIndex === undefined) {
-            console.error("ERR: image is missing", imgIndex);
+            testAssert(false, `imageIndexMap missing texture: ${this.inputObject.getName() || "<unnamed>"}`);
+            console.error("ERR: image is missing");
             return -1;
         }
         // ensure we have a texture array
@@ -878,11 +893,22 @@ 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 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];
+            // Remove EXT_texture_exr if the texture was converted (e.g. EXR → KTX2 via PMREM)
+            if (extensions["EXT_texture_exr"] && this.inputObject.getMimeType() !== "image/exr") {
+                delete extensions["EXT_texture_exr"];
+            }
+            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/extensions/NEEDLE_pmrem/index.d.ts

@@ -0,0 +1,19 @@
+import { Extension, Texture, WriterContext } from '@gltf-transform/core';
+/**
+ * NEEDLE_pmrem extension for gltf-transform.
+ * Marks textures that have been pre-processed with PMREM (EXR → KTX2 HDR).
+ * At write time, adds `NEEDLE_pmrem: { source: imageIndex }` to each marked texture
+ * so the Needle Engine runtime can load them correctly with CubeUVReflectionMapping.
+ */
+export declare class NEEDLE_pmrem extends Extension {
+    static readonly EXTENSION_NAME = "NEEDLE_pmrem";
+    readonly extensionName = "NEEDLE_pmrem";
+    /** Textures that were converted from EXR via PMREM */
+    private readonly pmremTextures;
+    /** Mark a texture as PMREM-converted */
+    addTexture(texture: Texture): void;
+    /** @hidden */
+    read(): this;
+    /** @hidden */
+    write(context: WriterContext): this;
+}

package/dist/extensions/NEEDLE_pmrem/index.js

@@ -0,0 +1,44 @@
+import { Extension } from '@gltf-transform/core';
+const EXTENSION_NAME = 'NEEDLE_pmrem';
+/**
+ * NEEDLE_pmrem extension for gltf-transform.
+ * Marks textures that have been pre-processed with PMREM (EXR → KTX2 HDR).
+ * At write time, adds `NEEDLE_pmrem: { source: imageIndex }` to each marked texture
+ * so the Needle Engine runtime can load them correctly with CubeUVReflectionMapping.
+ */
+export class NEEDLE_pmrem extends Extension {
+    static EXTENSION_NAME = EXTENSION_NAME;
+    extensionName = EXTENSION_NAME;
+    /** Textures that were converted from EXR via PMREM */
+    pmremTextures = new Set();
+    /** Mark a texture as PMREM-converted */
+    addTexture(texture) {
+        this.pmremTextures.add(texture);
+    }
+    /** @hidden */
+    read() {
+        return this;
+    }
+    /** @hidden */
+    write(context) {
+        const jsonDoc = context.jsonDoc;
+        for (const texture of this.pmremTextures) {
+            const imageIndex = context.imageIndexMap.get(texture);
+            if (imageIndex === undefined)
+                continue;
+            // Find texture defs that reference this image
+            for (const textureDef of jsonDoc.json.textures ?? []) {
+                const source = textureDef.source
+                    ?? textureDef.extensions?.['KHR_texture_basisu']?.source;
+                if (source === imageIndex) {
+                    textureDef.extensions = textureDef.extensions || {};
+                    textureDef.extensions[EXTENSION_NAME] = { source: imageIndex };
+                    // Remove KHR_texture_basisu so the runtime NEEDLE_pmrem plugin handles loading
+                    // (otherwise three.js's built-in KHR_texture_basisu handler intercepts it first)
+                    delete textureDef.extensions['KHR_texture_basisu'];
+                }
+            }
+        }
+        return this;
+    }
+}

package/dist/extensions/index.d.ts

@@ -4,4 +4,5 @@ export * from "./NEEDLE_compression_texture/index.js";
 export * from "./NEEDLE_progressive/index.js";
 export * from "./NEEDLE_progressive_texture_settings/index.js";
 export * from "./NEEDLE_progressive_mesh_settings/index.js";
+export * from "./NEEDLE_pmrem/index.js";
 export declare function registerExtensions(node: any): void;

package/dist/extensions/index.js

@@ -5,6 +5,7 @@ export * from "./NEEDLE_compression_texture/index.js";
 export * from "./NEEDLE_progressive/index.js";
 export * from "./NEEDLE_progressive_texture_settings/index.js";
 export * from "./NEEDLE_progressive_mesh_settings/index.js";
+export * from "./NEEDLE_pmrem/index.js";
 import { ALL_EXTENSIONS } from '@gltf-transform/extensions';
 import { ALL_EXTENSIONS as NEEDLE_EXTENSIONS } from "./NEEDLE_opaque/index.js";
 import { NEEDLE_progressive } from './NEEDLE_progressive/index.js';

package/dist/scripts/pack-gltf.js

@@ -5,10 +5,11 @@ import draco3d from 'draco3dgltf';
 import { existsSync, readFileSync, statSync, writeFileSync } from 'fs';
 import { MeshoptDecoder, MeshoptEncoder } from 'meshoptimizer';
 import { dedup, metalRough, prune, resample } from '@gltf-transform/functions';
-import { ALL_EXTENSIONS as NEEDLE_EXTENSIONS, NEEDLE_compression_texture, NEEDLE_mesh_compression, } from '../extensions/index.js';
+import { ALL_EXTENSIONS as NEEDLE_EXTENSIONS, NEEDLE_compression_texture, NEEDLE_mesh_compression, NEEDLE_pmrem, } from '../extensions/index.js';
 import { isLOD, isMeshLOD, needle_animation_transform, needle_asset, needle_mesh_transform, needle_texture_transform, } from '../transforms/index.js';
 import { getOutputPath, getVersion, ioTryReadWithMissingResources, writeNodeIO } from "../utils/index.js";
 import { addToCache, getHash, tryGetFromCache, } from "../cache/index.js";
+import { TestAssertionError } from '../utils/test-assert.js';
 /** Compress a glTF file
  */
 export async function packGLTF(inputFile, outputFile, options) {
@@ -56,6 +57,7 @@ export async function packGLTF(inputFile, outputFile, options) {
             .registerExtensions([
             NEEDLE_compression_texture,
             NEEDLE_mesh_compression,
+            NEEDLE_pmrem,
         ])
             .registerDependencies({
             'draco3d.decoder': await draco3d.createDecoderModule(),
@@ -64,8 +66,13 @@ export async function packGLTF(inputFile, outputFile, options) {
             'meshopt.encoder': MeshoptEncoder,
         });
         const document = await ioTryReadWithMissingResources(io, inputFile); // await io.read(inputFile);
-        /** @ts-ignore */
-        document.getLogger().verbosity = options.verbose ? Verbosity.DEBUG : options.debug ? Verbosity.INFO : Verbosity.WARN;
+        if (options.logger) {
+            document.setLogger(options.logger);
+        }
+        else {
+            /** @ts-ignore */
+            document.getLogger().verbosity = options.verbose ? Verbosity.DEBUG : options.debug ? Verbosity.INFO : Verbosity.WARN;
+        }
         let totalGPUTextureMemory = 0;
         /** @type {Array<import('@gltf-transform/core').Transform>} */
         const transforms = [
@@ -128,7 +135,10 @@ 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}`);
+        if (err instanceof TestAssertionError)
+            throw err;
+        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_pmrem.d.ts

@@ -0,0 +1,16 @@
+import { Document, Texture } from '@gltf-transform/core';
+import { NEEDLE_compression_texture_schema } from '../extensions/index.js';
+import { INeedleTextureTransformContext, NeedleTransformContext } from './needle_common.js';
+export declare class NeedlePmremContext implements INeedleTextureTransformContext {
+    private wasmModule;
+    private pmremDir;
+    private basisuExe;
+    private tmpDir;
+    private processed;
+    private available;
+    private logger;
+    private readonly convertedTextures;
+    prepare(document: Document): Promise<boolean>;
+    process(index: number, texture: Texture, _settings: NEEDLE_compression_texture_schema | null, _context: NeedleTransformContext): Promise<boolean>;
+    finalize(document: Document): Promise<void>;
+}

package/dist/transforms/needle_pmrem.js

@@ -0,0 +1,172 @@
+import { NEEDLE_pmrem } from '../extensions/index.js';
+import { existsSync, readFileSync, writeFileSync, mkdirSync, rmSync, chmodSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath, pathToFileURL } from 'url';
+import { execFile } from 'child_process';
+import { v4 as uuid } from 'uuid';
+import tmp from 'tmp';
+/** Resolve the tools/pmrem/ directory relative to this file.
+ *  At runtime this file is at dist/transforms/needle_pmrem.js,
+ *  so tools/pmrem/ is at ../../tools/pmrem/ */
+function getPmremDir() {
+    const thisDir = dirname(fileURLToPath(import.meta.url));
+    return join(thisDir, '..', '..', 'tools', 'pmrem');
+}
+function resolveBasisuExe(pmremDir) {
+    const platform = process.platform;
+    const base = join(pmremDir, 'basis');
+    if (platform === 'win32')
+        return join(base, 'win', 'basisu.exe');
+    if (platform === 'darwin')
+        return join(base, 'osx', 'basisu');
+    return join(base, 'linux', 'basisu');
+}
+function encodeKTX2WithBasisu(basisuExe, exrPath, outPath, variant, mipmaps) {
+    return new Promise((resolve, reject) => {
+        const args = [];
+        args.push(variant === 'hdr6x6' ? '-hdr_6x6' : '-hdr_4x4');
+        if (mipmaps)
+            args.push('-mipmap');
+        args.push('-file', exrPath, '-output_file', outPath, '-y_flip');
+        execFile(basisuExe, args, { windowsHide: true, encoding: 'utf8' }, (err, _stdout, stderr) => {
+            if (err) {
+                reject(new Error(`basisu failed: ${stderr || err.message}`));
+                return;
+            }
+            resolve();
+        });
+    });
+}
+export class NeedlePmremContext {
+    wasmModule = null;
+    pmremDir = '';
+    basisuExe = '';
+    tmpDir = '';
+    processed = 0;
+    available = false;
+    logger;
+    convertedTextures = [];
+    async prepare(document) {
+        this.logger = document.getLogger();
+        this.processed = 0;
+        this.pmremDir = getPmremDir();
+        // Check WASM exists
+        const wasmJsPath = join(this.pmremDir, 'pkg', 'pmrem_wasm.js');
+        const wasmBinPath = join(this.pmremDir, 'pkg', 'pmrem_wasm_bg.wasm');
+        if (!existsSync(wasmJsPath) || !existsSync(wasmBinPath)) {
+            this.logger.warn('pmrem: WASM not found — EXR textures will not be processed');
+            return false;
+        }
+        // Check basisu binary
+        this.basisuExe = resolveBasisuExe(this.pmremDir);
+        if (!existsSync(this.basisuExe)) {
+            this.logger.warn(`pmrem: basisu binary not found at ${this.basisuExe} — EXR textures will not be processed`);
+            return false;
+        }
+        // Set executable permission
+        if (process.platform !== 'win32') {
+            try {
+                chmodSync(this.basisuExe, 0o755);
+            }
+            catch { /* ignore */ }
+        }
+        // Load WASM
+        try {
+            const mod = await import(pathToFileURL(wasmJsPath).href);
+            const wasmBytes = readFileSync(wasmBinPath);
+            await mod.default({ module_or_path: wasmBytes });
+            this.wasmModule = mod;
+        }
+        catch (err) {
+            this.logger.warn(`pmrem: Failed to load WASM — ${err.message}`);
+            return false;
+        }
+        // Create temp directory
+        this.tmpDir = join(tmp.tmpdir, 'needle-pmrem');
+        mkdirSync(this.tmpDir, { recursive: true });
+        this.available = true;
+        this.logger.debug('pmrem: Ready (WASM + basisu loaded)');
+        return true;
+    }
+    async process(index, texture, _settings, _context) {
+        if (!this.available)
+            return false;
+        if (texture.getMimeType() !== 'image/exr')
+            return false;
+        const image = texture.getImage();
+        if (!image)
+            return false;
+        const name = texture.getName() || `texture_${index}`;
+        const id = uuid();
+        // 1. Run PMREM on the EXR bytes
+        this.logger.info(`pmrem:texture[${index}] ${name}: Running PMREM...`);
+        const exrBytes = new Uint8Array(image.buffer, image.byteOffset, image.byteLength);
+        const pmremExrBytes = this.wasmModule.pmrem_exr(exrBytes);
+        // 2. Write PMREM EXR to temp file
+        const tempExr = join(this.tmpDir, `${id}.pmrem.exr`);
+        const tempKtx2 = join(this.tmpDir, `${id}.ktx2`);
+        writeFileSync(tempExr, Buffer.from(pmremExrBytes));
+        // 3. Encode to KTX2 HDR via basisu
+        this.logger.debug(`pmrem:texture[${index}] ${name}: Encoding KTX2 HDR...`);
+        const variant = 'hdr4x4'; // 6x6 needs an update in Needle
+        await encodeKTX2WithBasisu(this.basisuExe, tempExr, tempKtx2, variant, true);
+        if (!existsSync(tempKtx2)) {
+            throw new Error(`pmrem:texture[${index}] ${name}: basisu did not produce output`);
+        }
+        // 4. Read KTX2 and update texture
+        const ktx2Bytes = readFileSync(tempKtx2);
+        texture.setImage(new Uint8Array(ktx2Bytes));
+        texture.setMimeType('image/ktx2');
+        // Remove EXT_texture_exr property since the texture is now KTX2
+        const exrProp = texture.getExtension('EXT_texture_exr');
+        if (exrProp) {
+            texture.setExtension('EXT_texture_exr', null);
+            exrProp.dispose();
+        }
+        // Update URI
+        const uri = texture.getURI();
+        if (uri) {
+            const newUri = uri.replace(/\.exr$/i, '.pmrem.ktx2');
+            texture.setURI(newUri !== uri ? newUri : uri + '.pmrem.ktx2');
+        }
+        // Report size (< 100 KB report in KB otherwise in MB)
+        const sizeStr = image.byteLength < 100 * 1024
+            ? `${(image.byteLength / 1024).toFixed(0)} KB`
+            : `${(image.byteLength / (1024 * 1024)).toFixed(2)} MB`;
+        const dstSizestr = ktx2Bytes.length < 100 * 1024
+            ? `${(ktx2Bytes.length / 1024).toFixed(0)} KB`
+            : `${(ktx2Bytes.length / (1024 * 1024)).toFixed(2)} MB`;
+        this.logger.info(`pmrem:texture[${index}] ${name}: ${sizeStr} EXR → ${dstSizestr} KTX2`);
+        this.convertedTextures.push(texture);
+        this.processed++;
+        return true;
+    }
+    async finalize(document) {
+        if (this.processed > 0) {
+            // Register NEEDLE_pmrem extension and mark converted textures
+            // Note: we do NOT register KHR_texture_basisu here — the NEEDLE_pmrem extension
+            // writer removes KHR_texture_basisu from texture defs so the runtime NEEDLE_pmrem
+            // plugin handles loading instead of three.js's built-in handler.
+            const pmremExt = document.createExtension(NEEDLE_pmrem);
+            for (const tex of this.convertedTextures) {
+                pmremExt.addTexture(tex);
+            }
+            // If no textures use EXR anymore, remove the EXT_texture_exr extension from the document
+            const hasExr = document.getRoot().listTextures().some(t => t.getMimeType() === 'image/exr');
+            if (!hasExr) {
+                const exrExt = document.getRoot().listExtensionsUsed()
+                    .find(e => e.extensionName === 'EXT_texture_exr');
+                if (exrExt) {
+                    exrExt.dispose();
+                }
+            }
+        }
+        // Clean up temp directory
+        if (this.tmpDir && existsSync(this.tmpDir)) {
+            try {
+                rmSync(this.tmpDir, { recursive: true });
+            }
+            catch { /* ignore */ }
+        }
+    }
+}

package/dist/transforms/needle_progressive.js

@@ -13,6 +13,7 @@ import { needle_asset, writeNeedleAsset } from './needle_asset.js';
 import { MeshoptDecoder, MeshoptEncoder, MeshoptSimplifier } from 'meshoptimizer';
 import { compressPrimitive, determineMeshCompression } from './needle_mesh_transform.js';
 import { calculateMeshDensity, getMeshInformation } from "../utils/mesh.js";
+import { TestAssertionError } from '../utils/test-assert.js';
 export async function make_progressive(opts) {
     const file = opts.path;
     let success = true;
@@ -78,9 +79,14 @@ async function onProcess(file, opts) {
         });
         let document = await ioTryReadWithMissingResources(io, file); // await io.read(file);
         if (document) {
-            const logger = document.getLogger();
-            //@ts-ignore
-            logger.verbosity = (opts.debug || opts.verbose) ? Verbosity.DEBUG : Verbosity.WARN;
+            if (opts.logger) {
+                document.setLogger(opts.logger);
+            }
+            else {
+                //@ts-ignore
+                document.getLogger().verbosity = (opts.debug || opts.verbose) ? Verbosity.DEBUG : Verbosity.WARN;
+            }
+            const logger = opts.logger || document.getLogger();
             let smallesTextureSize = 128;
             if (opts.config.usecase === "product") {
                 smallesTextureSize = 512;
@@ -120,6 +126,8 @@ async function onProcess(file, opts) {
         }
     }
     catch (err) {
+        if (err instanceof TestAssertionError)
+            throw err;
         console.log("ERR: failed to process file \"" + file + "\", Reason: " + err.message, "\nStack:\n" + err.stack);
         return false;
     }
@@ -151,6 +159,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 +186,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 +224,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();
@@ -360,7 +377,7 @@ async function createTextureLod(args, opts) {
                     // see https://linear.app/needle/issue/NE-4985
                     newMaterial.setAlphaMode("BLEND");
                     newMaterial.setBaseColorTexture(newTexture);
-                    continue;
+                    break;
                 }
                 if (slot === "specularColorTexture") {
                     logger.info("Pass-through KHR_materials_pbrSpecularGlossiness specularColorTexture");
@@ -368,7 +385,7 @@ async function createTextureLod(args, opts) {
                     const prob = ext.createSpecular();
                     prob.setSpecularColorTexture(newTexture);
                     newMaterial.setExtension(KHRMaterialsSpecular.EXTENSION_NAME, prob);
-                    continue;
+                    break;
                 }
                 else if (slot === "specularTexture") {
                     logger.info("Pass-through KHR_materials_specular specularTexture");
@@ -376,7 +393,7 @@ async function createTextureLod(args, opts) {
                     const prob = ext.createSpecular();
                     prob.setSpecularTexture(newTexture);
                     newMaterial.setExtension(KHRMaterialsSpecular.EXTENSION_NAME, prob);
-                    continue;
+                    break;
                 }
                 logger.warn(`WARN: Unknown texture slot: ${slot} for texture ${textureIndex} → can not load progressively (all slots: ${slots.join(", ")})`);
                 return null;
@@ -524,7 +541,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/transforms/needle_texture_transform.d.ts

@@ -3,10 +3,12 @@ import { Transform } from '@gltf-transform/core';
 import { NeedleWebPContext } from "./needle_webp.js";
 import { NeedleTransformContext } from "./needle_common.js";
 import { NeedleToktxContext } from "./needle_toktx.js";
+import { NeedlePmremContext } from "./needle_pmrem.js";
 export declare function resizeTextureIfNecessary(texture: Texture): Promise<void>;
 interface NeedleTextureTransformContext extends NeedleTransformContext {
     webPContext: NeedleWebPContext;
     toktxContext: NeedleToktxContext;
+    pmremContext: NeedlePmremContext;
     reportGPUMemory?: (bytes: number) => void;
 }
 export declare const needle_texture_transform: (options: NeedleTransformContext & Pick<NeedleTextureTransformContext, "reportGPUMemory">) => Transform;