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

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/extensions/NEEDLE_lightmaps/index.d.ts

@@ -0,0 +1,41 @@
+import { Extension, PropertyType, ReaderContext, WriterContext } from '@gltf-transform/core';
+/**
+ * NEEDLE_lightmaps gltf-transform extension.
+ *
+ * Handles both embedded (`/textures/N` pointer) and external (`sunrise.exr` pointer) lightmaps.
+ *
+ * - **preread(TEXTURE)**: Injects external EXR files into the JSON document so the core reader
+ *   creates proper Texture objects from them.
+ * - **read()**: Resolves `/textures/N` pointers to Texture objects. Sets references so that
+ *   gltf-transform doesn't prune/dedup referenced textures.
+ * - **write()**: Updates pointer strings:
+ *   - Embedded textures: resolves to the new `/textures/N` index in the output.
+ *   - External textures: uses the Texture's current URI (e.g. updated by PMREM to `.pmrem.ktx2`).
+ */
+export declare class NEEDLE_lightmaps_ext extends Extension {
+    static readonly EXTENSION_NAME = "NEEDLE_lightmaps";
+    readonly extensionName = "NEEDLE_lightmaps";
+    readonly prereadTypes: PropertyType[];
+    readonly prewriteTypes: PropertyType[];
+    /** Set before io.read() to allow resolving external file paths in preread */
+    static inputFile: string;
+    /** The raw extension JSON from the input (mutated in-place during write) */
+    private extensionData;
+    /** Entries with resolved Texture references */
+    private resolved;
+    /** Image indices injected during preread (for external EXR files) */
+    private injectedImageIndices;
+    /** The ExtensionProperty that holds references to prevent dedup/prune */
+    private lightmapProp;
+    preread(context: ReaderContext, _propertyType: PropertyType): this;
+    read(context: ReaderContext): this;
+    prewrite(context: WriterContext, _propertyType: PropertyType): this;
+    write(context: WriterContext): this;
+    private pointersResolved;
+    private resolvePointers;
+    /**
+     * Find (or create) a texture def in the output JSON that references the given Texture.
+     * This replicates the logic from the opaque system's TextureIndexResolver.
+     */
+    private findOrCreateTextureIndex;
+}

package/dist/extensions/NEEDLE_lightmaps/index.js

@@ -0,0 +1,249 @@
+import { Extension, ExtensionProperty, PropertyType } from '@gltf-transform/core';
+import { existsSync, readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { isLightmap } from '../../utils/texture.js';
+const EXTENSION_NAME = 'NEEDLE_lightmaps';
+/**
+ * Opaque-like ExtensionProperty that holds NEEDLE_lightmaps data on the Root.
+ * This keeps gltf-transform from garbage-collecting referenced textures.
+ */
+class LightmapProperty extends ExtensionProperty {
+    static EXTENSION_NAME = EXTENSION_NAME;
+    propertyType = 'LightmapProperty';
+    parentTypes = [PropertyType.ROOT];
+    init() {
+        this.extensionName = EXTENSION_NAME;
+    }
+    getDefaults() {
+        return Object.assign(super.getDefaults(), {});
+    }
+    /** Public wrapper around protected setRef to register references */
+    setReference(name, value) {
+        this.setRef(name, value);
+    }
+}
+/**
+ * NEEDLE_lightmaps gltf-transform extension.
+ *
+ * Handles both embedded (`/textures/N` pointer) and external (`sunrise.exr` pointer) lightmaps.
+ *
+ * - **preread(TEXTURE)**: Injects external EXR files into the JSON document so the core reader
+ *   creates proper Texture objects from them.
+ * - **read()**: Resolves `/textures/N` pointers to Texture objects. Sets references so that
+ *   gltf-transform doesn't prune/dedup referenced textures.
+ * - **write()**: Updates pointer strings:
+ *   - Embedded textures: resolves to the new `/textures/N` index in the output.
+ *   - External textures: uses the Texture's current URI (e.g. updated by PMREM to `.pmrem.ktx2`).
+ */
+export class NEEDLE_lightmaps_ext extends Extension {
+    static EXTENSION_NAME = EXTENSION_NAME;
+    extensionName = EXTENSION_NAME;
+    prereadTypes = [PropertyType.TEXTURE];
+    prewriteTypes = [PropertyType.MATERIAL];
+    /** Set before io.read() to allow resolving external file paths in preread */
+    static inputFile = '';
+    /** The raw extension JSON from the input (mutated in-place during write) */
+    extensionData = null;
+    /** Entries with resolved Texture references */
+    resolved = [];
+    /** Image indices injected during preread (for external EXR files) */
+    injectedImageIndices = new Map();
+    /** The ExtensionProperty that holds references to prevent dedup/prune */
+    lightmapProp = null;
+    // ── preread ──────────────────────────────────────────────────
+    preread(context, _propertyType) {
+        const json = context.jsonDoc.json;
+        const ext = json.extensions?.[EXTENSION_NAME];
+        if (!ext?.textures)
+            return this;
+        const inputFile = NEEDLE_lightmaps_ext.inputFile;
+        const inputDir = inputFile ? dirname(inputFile) : '';
+        for (const entry of ext.textures) {
+            // Skip embedded pointers — handled in read()
+            if (entry.pointer.startsWith('/') || entry.pointer.startsWith('textures/'))
+                continue;
+            // External file path (e.g. "sunrise.exr")
+            if (!entry.pointer.match(/\.exr$/i))
+                continue;
+            const exrPath = inputDir ? join(inputDir, entry.pointer) : '';
+            if (!exrPath || !existsSync(exrPath)) {
+                this.document.getLogger().warn(`NEEDLE_lightmaps: External EXR not found: ${exrPath || entry.pointer}`);
+                continue;
+            }
+            // Read EXR bytes and inject into JSON so the core reader creates a Texture
+            const exrBytes = readFileSync(exrPath);
+            json.images = json.images || [];
+            json.textures = json.textures || [];
+            const imageIndex = json.images.length;
+            json.images.push({
+                uri: entry.pointer,
+                mimeType: 'image/exr',
+                name: entry.pointer,
+            });
+            json.textures.push({
+                source: imageIndex,
+                name: entry.pointer,
+            });
+            context.jsonDoc.resources[entry.pointer] = new Uint8Array(exrBytes);
+            this.injectedImageIndices.set(entry.pointer, imageIndex);
+            this.document.getLogger().info(`NEEDLE_lightmaps: Registered external EXR "${entry.pointer}" as image[${imageIndex}]`);
+        }
+        return this;
+    }
+    // ── read ─────────────────────────────────────────────────────
+    read(context) {
+        const json = context.jsonDoc.json;
+        const ext = json.extensions?.[EXTENSION_NAME];
+        if (!ext?.textures)
+            return this;
+        // Store the raw extension data — we'll mutate the pointers during write
+        this.extensionData = ext;
+        // Create the property and attach to root
+        const root = this.document.getRoot();
+        this.lightmapProp = new LightmapProperty(this.document.getGraph());
+        root.setExtension(EXTENSION_NAME, this.lightmapProp);
+        const textureDefs = json.textures || [];
+        const logger = this.document.getLogger();
+        for (const entry of ext.textures) {
+            let texture = null;
+            let inputTextureDef;
+            if (entry.pointer.startsWith('/textures/') || entry.pointer.startsWith('textures/')) {
+                // Embedded pointer — resolve to Texture via the JSON texture definition
+                const prefix = entry.pointer.startsWith('/') ? '/textures/' : 'textures/';
+                const texIndex = parseInt(entry.pointer.substring(prefix.length));
+                const texDef = textureDefs[texIndex];
+                if (texDef) {
+                    inputTextureDef = texDef;
+                    const imageIndex = texDef.source
+                        ?? texDef.extensions?.['EXT_texture_exr']?.source
+                        ?? texDef.extensions?.['KHR_texture_basisu']?.source;
+                    if (imageIndex !== undefined) {
+                        texture = context.textures[imageIndex] ?? null;
+                    }
+                }
+            }
+            else if (entry.pointer.match(/\.exr$/i)) {
+                // External pointer — find the Texture created from our injected image
+                const imageIndex = this.injectedImageIndices.get(entry.pointer);
+                if (imageIndex !== undefined) {
+                    texture = context.textures[imageIndex] ?? null;
+                    inputTextureDef = textureDefs.find(t => t.source === imageIndex);
+                }
+            }
+            if (texture) {
+                this.resolved.push({ entry, texture, inputTextureDef });
+                // Set a reference so gltf-transform won't prune/dedup this texture
+                const refName = `lightmap_${entry.pointer}`;
+                this.lightmapProp.setReference(refName, texture);
+                // Also keep a reference to the buffer
+                const buffer = this.document.getRoot().listBuffers()[0];
+                if (buffer) {
+                    this.lightmapProp.setReference('buffer', buffer);
+                }
+            }
+            else {
+                logger.warn(`NEEDLE_lightmaps: Could not resolve texture for pointer "${entry.pointer}"`);
+            }
+        }
+        // Lightmap workaround: prevent compression on lightmap textures (non-EXR)
+        const textures = this.document.getRoot().listTextures();
+        for (const tex of textures) {
+            if (isLightmap(tex) && tex.getMimeType() !== 'image/exr') {
+                const refName = `lightmapTexture_${tex.getName()}`;
+                this.lightmapProp.setReference(refName, tex);
+                logger.info(`Found lightmap texture "${tex.getName()}" (${tex.getMimeType()}) in ${EXTENSION_NAME}`);
+            }
+        }
+        return this;
+    }
+    // ── prewrite ─────────────────────────────────────────────────
+    prewrite(context, _propertyType) {
+        // Resolve pointers early so json.textures is populated for textures
+        // not used by any material (same pattern as opaque system)
+        this.resolvePointers(context);
+        return this;
+    }
+    // ── write ────────────────────────────────────────────────────
+    write(context) {
+        if (!this.extensionData)
+            return this;
+        // Resolve any remaining pointers
+        this.resolvePointers(context);
+        // Write the extension data to the output JSON
+        context.jsonDoc.json.extensions = context.jsonDoc.json.extensions || {};
+        context.jsonDoc.json.extensions[EXTENSION_NAME] = this.extensionData;
+        return this;
+    }
+    // ── private ──────────────────────────────────────────────────
+    pointersResolved = false;
+    resolvePointers(context) {
+        if (this.pointersResolved)
+            return;
+        this.pointersResolved = true;
+        for (const { entry, texture, inputTextureDef } of this.resolved) {
+            if (entry.pointer.startsWith('/textures/') || entry.pointer.startsWith('textures/')) {
+                // Embedded: find the new texture index in the output JSON
+                const newIndex = this.findOrCreateTextureIndex(context, texture, inputTextureDef);
+                if (newIndex !== undefined) {
+                    entry.pointer = `/textures/${newIndex}`;
+                }
+            }
+            else {
+                // External: use the texture's current URI (may have been updated by PMREM)
+                const uri = texture.getURI();
+                if (uri) {
+                    entry.pointer = uri;
+                    // Ensure the image definition in the output JSON has the URI set.
+                    // When PMREM clears image data (setImage(null)) for external textures,
+                    // gltf-transform's core writer won't set a uri or bufferView on the image.
+                    const imageIndex = context.imageIndexMap.get(texture);
+                    if (imageIndex !== undefined) {
+                        const images = context.jsonDoc.json.images;
+                        if (images && images[imageIndex]) {
+                            images[imageIndex].uri = uri;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Find (or create) a texture def in the output JSON that references the given Texture.
+     * This replicates the logic from the opaque system's TextureIndexResolver.
+     */
+    findOrCreateTextureIndex(context, texture, inputTextureDef) {
+        const imageIndex = context.imageIndexMap.get(texture);
+        if (imageIndex === undefined)
+            return undefined;
+        const textures = context.jsonDoc.json.textures = context.jsonDoc.json.textures || [];
+        // Try to find an existing texture def pointing to the same image
+        for (let i = 0; i < textures.length; i++) {
+            const texDef = textures[i];
+            const source = texDef.source
+                ?? texDef.extensions?.['KHR_texture_basisu']?.source
+                ?? texDef.extensions?.['NEEDLE_pmrem']?.source;
+            if (source === imageIndex) {
+                return i;
+            }
+        }
+        // Not found — create a new texture definition
+        let extensions = inputTextureDef?.extensions ? { ...inputTextureDef.extensions } : undefined;
+        if (extensions) {
+            // Remove consumed extensions
+            delete extensions['NEEDLE_progressive_texture_settings'];
+            // Remove EXT_texture_exr if texture was converted
+            if (extensions['EXT_texture_exr'] && texture.getMimeType() !== 'image/exr') {
+                delete extensions['EXT_texture_exr'];
+            }
+            if (Object.keys(extensions).length === 0)
+                extensions = undefined;
+        }
+        const hasExtSource = extensions && Object.values(extensions).some((v) => v?.source !== undefined);
+        const texDef = {
+            source: hasExtSource ? undefined : imageIndex,
+            extensions,
+        };
+        textures.push(texDef);
+        return textures.length - 1;
+    }
+}

package/dist/extensions/NEEDLE_opaque/NEEDLE_opaque.js

@@ -2,6 +2,7 @@ import { Extension, ExtensionProperty, PropertyType, Node, TextureChannel } from
 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]);
@@ -414,11 +415,16 @@ class TextureHandler {
         }
     }
     write(ctx) {
+        // 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) {
-            if (this.key !== "EXT_texture_exr" && this.debug) {
+            if (this.debug) {
                 console.warn("WARN: failed to resolve image index for texture via imageIndexMap:", this.key, this.textureRef.getName() || "<unnamed>");
             }
             return;
@@ -430,10 +436,10 @@ class TextureHandler {
                 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 };
@@ -441,10 +447,13 @@ 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) {
+            if (this.debug) {
                 console.warn("WARN: failed to re-assign extension:", this.key, "imageIndex", imageIndex, textureDefs.length, this.textureRef.getName() || "<unnamed>", this.textureDefinition);
             }
         }
@@ -862,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
@@ -883,10 +893,14 @@ 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);
-        // Remove settings-only extensions that are consumed during processing and should not appear in the output.
+        // 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;
         }

package/dist/extensions/NEEDLE_opaque/index.js

@@ -10,7 +10,7 @@ export const ALL_EXTENSIONS = [
     createOpaqueExtension("NEEDLE_gameobject_data", PropertyType.NODE, { ...opaqueOptions }),
     createOpaqueExtension("NEEDLE_components", PropertyType.NODE, { ...opaqueOptions }),
     createOpaqueExtension("NEEDLE_persistent_assets", PropertyType.ROOT, { ...opaqueOptions }),
-    createOpaqueExtension("NEEDLE_lightmaps", PropertyType.ROOT, { ...opaqueOptions }),
+    // NEEDLE_lightmaps is now handled by its own dedicated extension (NEEDLE_lightmaps/index.ts)
     createOpaqueExtension("NEEDLE_lighting_settings", PropertyType.ROOT, { ...opaqueOptions }),
     createOpaqueExtension("NEEDLE_render_objects", PropertyType.ROOT, { ...opaqueOptions }),
     createOpaqueExtension("NEEDLE_progressive", [PropertyType.TEXTURE, PropertyType.MATERIAL, PropertyType.MESH], { ...opaqueOptions }),

package/dist/extensions/NEEDLE_pmrem/index.d.ts

@@ -0,0 +1,21 @@
+import { Extension, PropertyType, ReaderContext, 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 */
+    preread(context: ReaderContext, _propertyType: PropertyType): this;
+    /** @hidden */
+    read(context: ReaderContext): this;
+    /** @hidden */
+    write(context: WriterContext): this;
+}

package/dist/extensions/NEEDLE_pmrem/index.js

@@ -0,0 +1,95 @@
+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 */
+    preread(context, _propertyType) {
+        const json = context.jsonDoc.json;
+        // For each texture with NEEDLE_pmrem, ensure `source` is set so the core reader
+        // links the texture to its image (we removed KHR_texture_basisu.source at write time).
+        for (const textureDef of json.textures ?? []) {
+            const pmrem = textureDef.extensions?.[EXTENSION_NAME];
+            if (pmrem?.source !== undefined && textureDef.source === undefined) {
+                textureDef.source = pmrem.source;
+            }
+        }
+        // Also ensure the image has the correct mime type
+        for (const textureDef of json.textures ?? []) {
+            const pmrem = textureDef.extensions?.[EXTENSION_NAME];
+            if (pmrem?.source !== undefined) {
+                const imageDef = json.images?.[pmrem.source];
+                if (imageDef && !imageDef.mimeType) {
+                    imageDef.mimeType = 'image/ktx2';
+                }
+            }
+        }
+        return this;
+    }
+    /** @hidden */
+    read(context) {
+        const json = context.jsonDoc.json;
+        const textureDefs = json.textures ?? [];
+        const textures = this.document.getRoot().listTextures();
+        for (let i = 0; i < textureDefs.length; i++) {
+            const textureDef = textureDefs[i];
+            const pmrem = textureDef.extensions?.[EXTENSION_NAME];
+            if (pmrem?.source === undefined)
+                continue;
+            const texture = textures[i];
+            if (!texture)
+                continue;
+            texture.setMimeType('image/ktx2');
+            this.pmremTextures.add(texture);
+        }
+        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'];
+                }
+            }
+        }
+        // If no textures still use KHR_texture_basisu, remove it from extensionsUsed/Required
+        // to prevent KHRTextureBasisu.preread() from crashing when re-reading the GLB
+        const anyBasisu = (jsonDoc.json.textures ?? []).some((t) => t.extensions?.['KHR_texture_basisu']);
+        if (!anyBasisu) {
+            const remove = (arr) => {
+                if (!arr)
+                    return;
+                const idx = arr.indexOf('KHR_texture_basisu');
+                if (idx >= 0)
+                    arr.splice(idx, 1);
+            };
+            remove(jsonDoc.json.extensionsUsed);
+            remove(jsonDoc.json.extensionsRequired);
+        }
+        return this;
+    }
+}

package/dist/extensions/index.d.ts

@@ -4,4 +4,6 @@ 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 * from "./NEEDLE_lightmaps/index.js";
 export declare function registerExtensions(node: any): void;

package/dist/extensions/index.js

@@ -5,13 +5,19 @@ 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 * from "./NEEDLE_lightmaps/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';
+import { NEEDLE_pmrem } from './NEEDLE_pmrem/index.js';
+import { NEEDLE_lightmaps_ext } from './NEEDLE_lightmaps/index.js';
 export function registerExtensions(node) {
     node.registerExtensions(ALL_EXTENSIONS);
     node.registerExtensions(NEEDLE_EXTENSIONS);
     node.registerExtensions([
-        NEEDLE_progressive
+        NEEDLE_progressive,
+        NEEDLE_pmrem,
+        NEEDLE_lightmaps_ext,
     ]);
 }

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, NEEDLE_lightmaps_ext, } 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,8 @@ export async function packGLTF(inputFile, outputFile, options) {
             .registerExtensions([
             NEEDLE_compression_texture,
             NEEDLE_mesh_compression,
+            NEEDLE_pmrem,
+            NEEDLE_lightmaps_ext,
         ])
             .registerDependencies({
             'draco3d.decoder': await draco3d.createDecoderModule(),
@@ -63,9 +66,16 @@ export async function packGLTF(inputFile, outputFile, options) {
             'meshopt.decoder': MeshoptDecoder,
             '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;
+        // Set input file path so NEEDLE_lightmaps can resolve external EXR files during preread
+        NEEDLE_lightmaps_ext.inputFile = inputFile;
+        const document = await ioTryReadWithMissingResources(io, inputFile);
+        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,8 +138,10 @@ export async function packGLTF(inputFile, outputFile, options) {
         return true;
     }
     catch (err) {
+        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}`);
+        logger.error(`Packing of "${path.basename(inputFile)}" using version ${getVersion()} failed with error:\n${err instanceof Error ? err.message : String(err)}\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>;
+}