@needle-tools/gltf-build-pipeline 0.1.0

package/dist/transforms/needle_progressive.js

@@ -0,0 +1,264 @@
+import { BufferUtils, Document, NodeIO, PropertyType } from '@gltf-transform/core';
+import { listTextureSlots } from '@gltf-transform/functions';
+import { NEEDLE_PROGRESSIVE_TEXTURE_EXTENSION_NAME, NEEDLE_progressive, generateGuid } from "../extensions/NEEDLE_progressive/index.js";
+import { createOpaqueExtension, NEEDLE_compression_texture, NEEDLE_mesh_compression, NEEDLE_progressive_texture_settings, registerExtensions as registerDefaultExtensions } from '../extensions/index.js';
+import path from 'path';
+import { existsSync } from 'fs';
+import { addToCache, getKey, tryGetFromCache } from '../cache/index.js';
+import sharp from "sharp";
+import { foreachGLTF } from '../utils/index.js';
+import { needle_asset } from './needle_asset.js';
+function registerExtensions(io) {
+    registerDefaultExtensions(io);
+    io.registerExtensions([
+        NEEDLE_progressive,
+        NEEDLE_progressive_texture_settings,
+        //@ts-ignore
+        createOpaqueExtension(NEEDLE_compression_texture.EXTENSION_NAME, PropertyType.TEXTURE),
+        //@ts-ignore
+        createOpaqueExtension(NEEDLE_mesh_compression.EXTENSION_NAME, [PropertyType.MESH, PropertyType.PRIMITIVE])
+    ]);
+}
+export async function make_progressive(opts) {
+    console.log("INFO: Run progressive transform: " + opts.path);
+    const file = opts.path;
+    const tasks = [];
+    foreachGLTF(file, f => {
+        const prog = process(f, opts);
+        tasks.push(prog);
+    });
+    await Promise.all(tasks);
+}
+async function process(file, opts) {
+    if (!file.endsWith(".glb") && !file.endsWith(".gltf")) {
+        console.log("ERR: file is not gltf/glb");
+        return;
+    }
+    if (!existsSync(file)) {
+        console.log("ERR: file does not exist: " + file);
+    }
+    const io = new NodeIO();
+    registerExtensions(io);
+    const document = await io.read(file).catch((err) => {
+        console.log("ERR: failed to read file \"" + file + "\", Reason: " + err.message);
+        return;
+    });
+    if (document) {
+        if (opts.debug === true) {
+            if (file.includes(".debug.")) {
+                console.log("Skip debug file: " + file);
+                return;
+            }
+        }
+        //@ts-ignore
+        document.getLogger().verbosity = 0;
+        await document.transform(needle_asset(), make_progressive_textures(file, { size: [256, 256] }, opts));
+        let filename = file;
+        if (opts.debug === true) {
+            // get extension
+            const extension = filename.split('.').pop();
+            // remove extension
+            filename = filename.split('.').slice(0, -1).join('.');
+            // add new extension
+            filename = filename + ".debug." + extension;
+        }
+        io.write(filename, document);
+    }
+}
+// basic idea:
+// 1. iterate all images that have an extension marking them to be progressively loaded
+// 2. for each image, create a new image that is a downsampled version of the original and create a new gltf that contains the high res texture
+// 3. add extension to low res image containing info about where to find the high res texture
+export function createTransform(name, fn) {
+    Object.defineProperty(fn, 'name', { value: name });
+    return fn;
+}
+const NAME = 'textureResize';
+export function make_progressive_textures(filePath, _options = TEXTURE_RESIZE_DEFAULTS, opts) {
+    console.log("Make progressive: " + filePath);
+    const startTime = Date.now();
+    const options = { ...TEXTURE_RESIZE_DEFAULTS, ..._options };
+    const directory = path.dirname(filePath);
+    // const fileNameWithoutExtension = path.basename(filePath, path.extname(filePath));
+    const textureLodBasePath = directory + "/";
+    return createTransform(NAME, async (doc) => {
+        const logger = doc.getLogger();
+        let index = 0;
+        for (const texture of doc.getRoot().listTextures()) {
+            const textureIndex = index++;
+            const name = texture.getName();
+            const uri = texture.getURI();
+            const match = !options.pattern || options.pattern.test(name) || options.pattern.test(uri);
+            if (!match) {
+                logger.debug(`${NAME}: Skipping, excluded by "pattern" parameter.`);
+                continue;
+            }
+            if (texture.getMimeType() !== 'image/png' && texture.getMimeType() !== 'image/jpeg') {
+                logger.warn(`${NAME}: Skipping, unsupported texture type "${texture.getMimeType()}".`);
+                continue;
+            }
+            const slots = listTextureSlots(texture);
+            if (options.slots && !slots.some((slot) => options.slots?.test(slot))) {
+                logger.debug(`${NAME}: Skipping, [${slots.join(', ')}] excluded by "slots" parameter.`);
+                continue;
+            }
+            const settings = texture.getExtension(NEEDLE_progressive_texture_settings.EXTENSION_NAME);
+            if (!settings) {
+                logger.warn(`${NAME}: Skipping, no settings found`);
+                continue;
+            }
+            if (!settings.isValid) {
+                logger.warn(`${NAME}: Skipping, settings are invalid`);
+                continue;
+            }
+            options.size[0] = settings.maxSize;
+            options.size[1] = settings.maxSize;
+            const existingExtension = texture.getExtension(NEEDLE_PROGRESSIVE_TEXTURE_EXTENSION_NAME);
+            if (existingExtension !== undefined && existingExtension !== null) {
+                logger.debug(`${NAME}: Skipping, texture is already progressive`);
+                continue;
+            }
+            const progressiveExt = doc.createExtension(NEEDLE_progressive);
+            if (!progressiveExt || !progressiveExt.create) {
+                logger.debug(`${NAME}: Skipping because progressive extension is not available.`);
+                continue;
+            }
+            const textureGuid = settings.guid?.length ? settings.guid : generateGuid();
+            const outPath = createTextureLod(textureLodBasePath, 0, texture, slots, textureGuid, textureIndex);
+            if (!outPath) {
+                continue;
+            }
+            const relName = path.relative(directory, outPath);
+            // TODO: this path should be added to the NEEDLE dependencies extension
+            texture.setExtension(NEEDLE_PROGRESSIVE_TEXTURE_EXTENSION_NAME, progressiveExt.create({
+                uri: relName,
+                guid: textureGuid,
+                level: 0,
+            }));
+            const key = getKey(texture);
+            if (opts.useCache) {
+                const cached = tryGetFromCache(key);
+                if (cached) {
+                    logger.debug(`Progressive image ${index}: using cached preview version (size: ${options.size}))`);
+                    texture.setImage(cached);
+                    continue;
+                }
+            }
+            await resizeTexture(options, texture, logger, uri || name, slots);
+            addToCache(key, texture.getImage());
+        }
+        logger.debug(`Progressive transform finished in ${((Date.now() - startTime) / 1000).toFixed(1)} sec.`);
+    });
+}
+function createTextureLod(basePath, level, texture, slots, guid, textureIndex) {
+    // const imageBytes = texture.getImage();
+    // if (imageBytes) {
+    // 	// write bytes
+    // 	const outPath = basePath + guid + "_" + level + ".png";
+    // 	writeFileSync(outPath, imageBytes);
+    // 	return outPath;
+    // }
+    const newDoc = new Document();
+    newDoc.createScene();
+    newDoc.createBuffer();
+    // add texture
+    const newTexture = newDoc.createTexture();
+    const img = texture.getImage();
+    newTexture.setImage(img);
+    newTexture.setURI(texture.getURI());
+    newTexture.setMimeType(texture.getMimeType());
+    // create material adding the texture to the same slot
+    for (const slot of slots) {
+        const newMaterial = newDoc.createMaterial();
+        switch (slot) {
+            case "baseColorTexture":
+                newMaterial.setBaseColorTexture(newTexture);
+                break;
+            case "metallicRoughnessTexture":
+                newMaterial.setMetallicRoughnessTexture(newTexture);
+                break;
+            case "normalTexture":
+                newMaterial.setNormalTexture(newTexture);
+                break;
+            case "occlusionTexture":
+                newMaterial.setOcclusionTexture(newTexture);
+                break;
+            case "emissiveTexture":
+                newMaterial.setEmissiveTexture(newTexture);
+                break;
+            default:
+                console.warn("WARN: Unknown texture slot: " + slot + " for texture " + textureIndex + " → can not load progressively");
+                return null;
+        }
+    }
+    const compressionSettings = texture.getExtension(NEEDLE_compression_texture.EXTENSION_NAME);
+    if (compressionSettings !== undefined && compressionSettings !== null && compressionSettings.getExtensionDefinition) {
+        console.log("> Pass compression extension to new texture");
+        const newExt = newDoc.createExtension(NEEDLE_compression_texture);
+        const def = compressionSettings.getExtensionDefinition();
+        const newProp = newExt.create(def);
+        newTexture.setExtension(NEEDLE_compression_texture.EXTENSION_NAME, newProp);
+    }
+    // add progressive texture extension
+    const progressiveExt = newDoc.createExtension(NEEDLE_progressive);
+    newTexture.setExtension(NEEDLE_PROGRESSIVE_TEXTURE_EXTENSION_NAME, progressiveExt.create({
+        guid: guid,
+    }));
+    const newIo = new NodeIO();
+    registerExtensions(newIo);
+    const ext = ".glb";
+    const imageName = "image_" + level + "_" + guid;
+    const outName = basePath + imageName + ext;
+    newIo.write(outName, newDoc);
+    return outName;
+}
+/** Resampling filter methods. LANCZOS3 is sharper, LANCZOS2 is smoother. */
+export var TextureResizeFilter;
+(function (TextureResizeFilter) {
+    /** Lanczos3 (sharp) */
+    TextureResizeFilter["LANCZOS3"] = "lanczos3";
+    /** Lanczos2 (smooth) */
+    TextureResizeFilter["LANCZOS2"] = "lanczos2";
+})(TextureResizeFilter || (TextureResizeFilter = {}));
+export const TEXTURE_RESIZE_DEFAULTS = {
+    size: [2048, 2048],
+    filter: TextureResizeFilter.LANCZOS3,
+    pattern: null,
+    slots: null,
+};
+export async function resizeTextureToMax(texture, maxSize, logger) {
+    const options = { ...TEXTURE_RESIZE_DEFAULTS };
+    options.size = [maxSize, maxSize];
+    await resizeTexture(options, texture, logger);
+}
+async function resizeTexture(options, texture, logger, uri, slots) {
+    const [maxWidth, maxHeight] = options.size;
+    const [srcWidth, srcHeight] = texture.getSize();
+    if (srcWidth <= maxWidth && srcHeight <= maxHeight) {
+        logger.debug(`${NAME}: Skipping, not within size range.`);
+        return;
+    }
+    if (maxWidth <= 0 || maxHeight <= 0) {
+        logger.debug(`${uri}: Skipping, invalid size range: ${maxWidth}x${maxHeight}`);
+        return;
+    }
+    let dstWidth = srcWidth;
+    let dstHeight = srcHeight;
+    if (dstWidth > maxWidth) {
+        dstHeight = Math.floor(dstHeight * (maxWidth / dstWidth));
+        dstWidth = maxWidth;
+    }
+    if (dstHeight > maxHeight) {
+        dstWidth = Math.floor(dstWidth * (maxHeight / dstHeight));
+        dstHeight = maxHeight;
+    }
+    // https://sharp.pixelplumbing.com/api-resize
+    const buffer = await sharp(texture.getImage())
+        .resize(dstWidth, dstHeight, {
+        fit: 'inside',
+        kernel: "lanczos3",
+        withoutEnlargement: true,
+    })
+        .toBuffer();
+    texture.setImage(BufferUtils.toView(buffer));
+}

package/dist/transforms/needle_simplify.d.ts

@@ -0,0 +1,3 @@
+import { Transform } from "@gltf-transform/core";
+import { SimplifyOptions } from "@gltf-transform/functions";
+export declare const needle_mesh_transform: (options: SimplifyOptions) => Transform;

package/dist/transforms/needle_simplify.js

@@ -0,0 +1,76 @@
+import { Primitive } from "@gltf-transform/core";
+import { simplifyPrimitive, weldPrimitive } from "@gltf-transform/functions";
+import { MeshoptSimplifier } from "meshoptimizer";
+import { NEEDLE_mesh_compression } from "../extensions/index.js";
+const NAME = 'needle_simplify';
+export const needle_mesh_transform = function (options) {
+    const simplifier = MeshoptSimplifier;
+    if (!simplifier) {
+        throw new Error(`${NAME}: simplifier dependency required — install "meshoptimizer".`);
+    }
+    return (document, _context) => {
+        const logger = document.getLogger();
+        options = { ...options, simplifier: simplifier };
+        const weldOptions = {
+            tolerance: 0.00000000001,
+            overwrite: true
+        };
+        for (const mesh of document.getRoot().listMeshes()) {
+            for (const prim of mesh.listPrimitives()) {
+                // const key = getKey(prim);
+                // const cached = tryGetFromCache(key);
+                // if (cached) {
+                //     logger.debug(`${NAME}: Skipping primitive of mesh "${mesh.getName()}": Already cached.`);
+                //     continue;
+                // }
+                // updatePrimitive(prim, simplifier, null, prim.getIndices());
+                // continue;
+                const ext = prim.getExtension(NEEDLE_mesh_compression.EXTENSION_NAME);
+                if (!ext) {
+                    // logger.warn("Skipping primitive of mesh " + mesh.getName() + ": No NEEDLE_compression_mesh extension.");
+                    continue;
+                }
+                let meshOptions = { ...options };
+                if (ext.model) {
+                    const model = ext.model;
+                    if (!model.useSimplifier) {
+                        logger.debug(`${NAME}: Skipping primitive of mesh "${mesh.getName()}": useSimplifier is false.`);
+                        continue;
+                    }
+                    if (model.error >= 0)
+                        meshOptions.error = model.error;
+                    if (model.ratio >= 0)
+                        meshOptions.ratio = model.ratio;
+                    meshOptions.lockBorder = model.lockBorder;
+                }
+                if (prim.getMode() !== Primitive.Mode.TRIANGLES) {
+                    logger.warn(`${NAME}: Skipping primitive of mesh "${mesh.getName()}": Requires TRIANGLES draw mode.`);
+                    continue;
+                }
+                logger.debug(`${NAME}: Welding primitive of mesh "${mesh.getName()}" → tolerance: ${weldOptions.tolerance}`);
+                weldPrimitive(document, prim, weldOptions);
+                logger.debug(`${NAME}: Simplifying primitive of mesh "${mesh.getName()}" → ratio: ${meshOptions.ratio}, error: ${meshOptions.error}, lockBorder: ${meshOptions.lockBorder}`);
+                simplifyPrimitive(document, prim, meshOptions);
+            }
+        }
+    };
+};
+// function updatePrimitive(prim: Primitive, simplifier: any, positionArray, dstIndicesArray) {
+// 	const position = prim.getAttribute('POSITION')!;
+// 	const srcIndices = prim.getIndices()!;
+// 	const srcVertexCount = position.getCount();
+//     const [remap, unique] = simplifier.compactMesh(dstIndicesArray);
+//     // logger.debug(`${NAME}: ${formatDeltaOp(position.getCount(), unique)} vertices, error: ${error.toFixed(4)}.`);
+//     // (3) Write vertex attributes.
+//     for (const srcAttribute of deepListAttributes(prim)) {
+//         const dstAttribute = srcAttribute.clone();
+//         remapAttribute(dstAttribute, remap, unique);
+//         deepSwapAttribute(prim, srcAttribute, dstAttribute);
+//         if (srcAttribute.listParents().length === 1) srcAttribute.dispose();
+//     }
+//     // (4) Write indices.
+//     const dstIndices = srcIndices.clone();
+//     dstIndices.setArray(srcVertexCount <= 65534 ? new Uint16Array(dstIndicesArray) : dstIndicesArray);
+//     prim.setIndices(dstIndices);
+//     if (srcIndices.listParents().length === 1) srcIndices.dispose();
+// }

package/dist/transforms/needle_texture_transform.d.ts

@@ -0,0 +1,5 @@
+import { Texture } from "@gltf-transform/core";
+import { Transform } from '@gltf-transform/core';
+import { NeedleTransformContext } from "./needle_common.js";
+export declare function resizeTextureIfNecessary(texture: Texture): Promise<void>;
+export declare const needle_texture_transform: (options: NeedleTransformContext) => Transform;

package/dist/transforms/needle_texture_transform.js

@@ -0,0 +1,123 @@
+import { resizeTextureToMax } from "./needle_progressive.js";
+import { NEEDLE_compression_texture } from '../extensions/index.js';
+import { addToCache, getKey, tryGetFromCache } from "../cache/index.js";
+import { NeedleWebPContext } from "./needle_webp.js";
+import { NeedleToktxContext } from "./needle_toktx.js";
+import { createTransform } from "@gltf-transform/functions";
+export async function resizeTextureIfNecessary(texture) {
+    const ext = texture.getExtension(NEEDLE_compression_texture.EXTENSION_NAME);
+    if (ext?.model) {
+        const mimeType = texture.getMimeType();
+        const isSupported = mimeType === "image/jpeg" || mimeType === "image/png";
+        if (isSupported) {
+            const settings = ext.model;
+            const size = texture.getSize();
+            if (size) {
+                if (settings.maxSize > 4 && (size[0] > settings.maxSize || size[1] > settings.maxSize)) {
+                    console.log(`> Will resize texture ${texture.getName()} from ${size[0]}x${size[1]} to ${settings.maxSize}x${settings.maxSize}`);
+                    await resizeTextureToMax(texture, settings.maxSize, console);
+                }
+            }
+        }
+    }
+    return undefined;
+}
+export const needle_texture_transform = function (options) {
+    const webPContext = new NeedleWebPContext({});
+    const toktxContext = new NeedleToktxContext({
+        jobs: undefined, // default to number of cores
+    });
+    const context = {
+        ...options,
+        webPContext,
+        toktxContext
+    };
+    return createTransform("needle_texture_transform", async (document) => {
+        await webPContext.prepare(document);
+        if (context.noToktx !== true)
+            await toktxContext.prepare(document);
+        try {
+            const logger = document.getLogger();
+            const textures = document.getRoot().listTextures();
+            await Promise.all(textures.map((texture, textureIndex) => {
+                return processTexture(texture, textureIndex, document, logger, context);
+            }));
+        }
+        finally {
+            await webPContext.finalize(document);
+            if (context.noToktx !== true)
+                await toktxContext.finalize(document);
+        }
+    });
+};
+async function processTexture(texture, index, document, logger, context) {
+    const mimeType = texture.getMimeType();
+    const isSupported = mimeType === "image/jpeg" || mimeType === "image/png" || mimeType === "image/webp";
+    // dont try to transform EXR or already processed textures
+    if (!isSupported)
+        return;
+    const ext = texture.getExtension(NEEDLE_compression_texture.EXTENSION_NAME);
+    const compressionSettings = ext?.model;
+    const key = context.useCache ? getKey(texture) : undefined;
+    let cached = context.useCache && key ? tryGetFromCache(key) : undefined;
+    if (cached) {
+        logger.debug(`> Using cached texture ${texture.getName()} [${index}] – ${(cached.length / 1024).toFixed(0)} KB`);
+        if (cached.length <= 0) {
+            logger.warn(`WARN: Cached texture ${texture.getName()} [${index}] is empty. Will reprocess.`);
+            cached = undefined;
+        }
+    }
+    let successFullyProcessed = false;
+    const canRunToktx = context.noToktx !== true;
+    if (compressionSettings && compressionSettings.mode !== "auto") {
+        switch (compressionSettings.mode) {
+            case "webp":
+                if (cached) {
+                    texture.setImage(cached).setMimeType("image/webp");
+                    return;
+                }
+                await resizeTextureIfNecessary(texture);
+                successFullyProcessed = await context.webPContext.process(index, texture, compressionSettings);
+                break;
+            case "ETC1S":
+                if (cached) {
+                    texture.setImage(cached).setMimeType("image/ktx2");
+                    return;
+                }
+                await resizeTextureIfNecessary(texture);
+                successFullyProcessed = await context.toktxContext.process(index, texture, compressionSettings);
+                break;
+            case "UASTC":
+                if (cached) {
+                    texture.setImage(cached).setMimeType("image/ktx2");
+                    return;
+                }
+                await resizeTextureIfNecessary(texture);
+                successFullyProcessed = await context.toktxContext.process(index, texture, compressionSettings);
+                break;
+        }
+    }
+    else {
+        // If we have a texture cached we can use it
+        // the default compression is toktx so we can safely use that for now
+        if (cached) {
+            texture.setImage(cached).setMimeType("image/ktx2");
+            return;
+        }
+        await resizeTextureIfNecessary(texture);
+        if (canRunToktx) {
+            // if no specific compression settings are provided we just use the toktx default settings
+            // if we ever change what is used for default compression we need to teach the cache to save the mime type
+            await context.toktxContext.process(index, texture, null);
+            successFullyProcessed = true;
+        }
+        else {
+            console.log("toktx is disallowed. Skipping texture compression.");
+        }
+    }
+    if (context.useCache && successFullyProcessed && key) {
+        const data = texture.getImage();
+        if (data)
+            addToCache(key, data);
+    }
+}

package/dist/transforms/needle_toktx.d.ts

@@ -0,0 +1,24 @@
+import { Document, Texture } from "@gltf-transform/core";
+import { KHRTextureBasisu } from "@gltf-transform/extensions";
+import { NEEDLE_compression_texture_schema } from "../extensions/index.js";
+import { INeedleTextureTransformContext } from "./needle_common.js";
+export interface NeedleToktxOptions {
+    jobs?: number;
+    toktxPath?: string;
+}
+export declare class NeedleToktxContext implements INeedleTextureTransformContext {
+    limit: any;
+    basisuExtension: KHRTextureBasisu;
+    version: string;
+    tmpPathBase: string;
+    document: Document;
+    env: undefined | {
+        PATH: string;
+    };
+    numTextures: number;
+    private _prepareFailed;
+    constructor(options: NeedleToktxOptions);
+    prepare(document: Document): Promise<void>;
+    process(index: number, texture: Texture, settings: NEEDLE_compression_texture_schema | null): Promise<boolean>;
+    finalize(document: Document): Promise<void>;
+}

package/dist/transforms/needle_toktx.js

@@ -0,0 +1,144 @@
+import { FileUtils, ImageUtils, uuid } from "@gltf-transform/core";
+import { KHRTextureBasisu } from "@gltf-transform/extensions";
+import { checkKTXSoftware, createParams, ETC1S_DEFAULTS, Mode, UASTC_DEFAULTS } from "./toktx.js";
+import { existsSync, mkdirSync } from "fs";
+import { listTextureSlots, getTextureChannelMask } from "@gltf-transform/functions";
+import { spawn, waitExit } from './util.js';
+import fs from 'fs/promises';
+import os from 'os';
+import tmp from 'tmp';
+import pLimit from 'p-limit';
+const NUM_CPUS = os.cpus().length || 1; // microsoft/vscode#112122
+export class NeedleToktxContext {
+    limit;
+    basisuExtension;
+    version;
+    tmpPathBase;
+    document;
+    env;
+    numTextures;
+    _prepareFailed = false;
+    constructor(options) {
+        this.limit = pLimit(options.jobs || NUM_CPUS);
+        // allow overriding toktx installation location / adding additional search paths
+        const isUsingWindows = process.platform === 'win32';
+        this.env = {
+            PATH: process.env.PATH ?? ""
+        };
+        if (options?.toktxPath?.length && this.env) {
+            this.env.PATH = `${options.toktxPath};${this.env.PATH}`;
+        }
+        // Use global env variable
+        if (process.env.NEEDLE_TOKTX?.length) {
+            if (!existsSync(process.env.NEEDLE_TOKTX)) {
+                console.log("WARN: NEEDLE_TOKTX is set to a non-existing path: \"" + process.env.NEEDLE_TOKTX + "\"");
+            }
+            else {
+                console.log("INFO: Adding NEEDLE_TOKTX to PATH: \"" + process.env.NEEDLE_TOKTX + "\"");
+                this.env.PATH = `${process.env.NEEDLE_TOKTX};${this.env.PATH}`;
+            }
+        }
+        else {
+            console.log("INFO: Environment variable 'NEEDLE_TOKTX' not set. Use 'NEEDLE_TOKTX' to specify the directory of the toktx installation (path/to/bin)");
+        }
+        // fallback default installation directory:
+        if (isUsingWindows) {
+            const defaultPath = "C:\\Program Files\\KTX-Software\\bin";
+            if (existsSync(defaultPath))
+                this.env.PATH = `${this.env.PATH};${defaultPath}`;
+        }
+        // append default system paths
+        if (isUsingWindows && process.env.Path?.length)
+            this.env.PATH = `${this.env.PATH};${process.env.Path}`;
+        if (process.argv?.includes("debug")) {
+            const ktxPaths = this.env.PATH.split(";").filter(p => p.toLocaleLowerCase().includes("ktx"));
+            console.log("INFO: Found these paths including ktx:\n\t" + ktxPaths.join("\n\t") + "");
+        }
+    }
+    async prepare(document) {
+        try {
+            this.document = document;
+            const logger = document.getLogger();
+            this.version = await checkKTXSoftware(logger, this.env);
+            this.basisuExtension = document.createExtension(KHRTextureBasisu).setRequired(true);
+            const tmpDir = `${tmp.tmpdir}/gltf-transform`;
+            if (!(existsSync(tmpDir)))
+                mkdirSync(tmpDir);
+            this.tmpPathBase = tmpDir + "/" + uuid();
+            this.numTextures = document.getRoot().listTextures().length;
+        }
+        catch (e) {
+            console.error(e);
+            this._prepareFailed = true;
+        }
+    }
+    async process(index, texture, settings) {
+        const task = async () => {
+            if (this._prepareFailed)
+                return false;
+            const doc = this.document;
+            const logger = doc.getLogger();
+            const slots = listTextureSlots(texture);
+            const channels = getTextureChannelMask(texture);
+            const textureLabel = texture.getURI() ||
+                texture.getName() ||
+                `${index + 1}/${doc.getRoot().listTextures().length}`;
+            const prefix = `toktx:texture(${textureLabel})`;
+            if (slots.length > 0)
+                logger.debug(`${prefix}: Slots → [${slots.join(', ')}]`);
+            const image = texture.getImage();
+            const size = texture.getSize();
+            if (!image || !size) {
+                logger.warn(`${prefix}: Skipping, unreadable texture.`);
+                return;
+            }
+            const extension = texture.getURI()
+                ? FileUtils.extension(texture.getURI())
+                : ImageUtils.mimeTypeToExtension(texture.getMimeType());
+            const tmpName = this.tmpPathBase + "_" + index;
+            const inPath = tmpName + '.' + extension;
+            const outPath = tmpName + '.ktx2';
+            // const inBytes = image.byteLength;
+            await fs.writeFile(inPath, Buffer.from(image));
+            //@ts-ignore
+            const defaults = (!settings || settings.mode === "ETC1S") ? ETC1S_DEFAULTS : UASTC_DEFAULTS;
+            defaults.mode = (!settings || settings.mode === "ETC1S") ? Mode.ETC1S : Mode.UASTC;
+            //@ts-ignore
+            const toktxParams = createParams(slots, channels, size, logger, this.numTextures, { ...defaults }, this.version);
+            const params = [
+                ...toktxParams,
+                outPath,
+                inPath,
+            ];
+            logger.debug(`${prefix}: Spawning → toktx ${params.join(' ')}`);
+            try {
+                // COMPRESS: Run `toktx` CLI tool.
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                //@ts-ignore
+                const [status, stdout, stderr] = await waitExit(spawn('toktx', params, { env: this.env }));
+                if (status !== 0) {
+                    logger.error(`${prefix}: Failed → \n\n${stderr.toString()}`);
+                }
+                else {
+                    const result = await fs.readFile(outPath);
+                    texture.setImage(result).setMimeType('image/ktx2');
+                    return true;
+                }
+            }
+            catch (err) {
+                console.error("Error running toktx", err);
+            }
+            return false;
+        };
+        return this.limit(task);
+    }
+    async finalize(document) {
+        const usesKTX2 = document
+            .getRoot()
+            .listTextures()
+            .some((t) => t.getMimeType() === 'image/ktx2');
+        if (!usesKTX2) {
+            this.basisuExtension?.dispose();
+        }
+    }
+}

package/dist/transforms/needle_webp.d.ts

@@ -0,0 +1,13 @@
+import { Document, ILogger, Texture } from '@gltf-transform/core';
+import { NEEDLE_compression_texture_schema } from '../extensions/index.js';
+import { INeedleTextureTransformContext } from './needle_common.js';
+export interface NeedleWebPOptions {
+}
+export declare class NeedleWebPContext implements INeedleTextureTransformContext {
+    options: NeedleWebPOptions;
+    logger: ILogger;
+    constructor(options: NeedleWebPOptions);
+    prepare(document: Document): Promise<void>;
+    process(index: number, texture: Texture, settings: NEEDLE_compression_texture_schema): Promise<boolean>;
+    finalize(document: Document): Promise<void>;
+}