@needle-tools/gltf-build-pipeline 2.13.0 → 2.13.1

package/dist/transforms/needle_mesh_transform.js

@@ -1,223 +1,223 @@
-import { Primitive } from "@gltf-transform/core";
-import { meshopt, simplifyPrimitive, SIMPLIFY_DEFAULTS, WELD_DEFAULTS, draco } from "@gltf-transform/functions";
-import { MeshoptEncoder, MeshoptSimplifier } from "meshoptimizer";
-import { NEEDLE_mesh_compression, NEEDLE_mesh_compression_model_root } from "../extensions/index.js";
-import { weldPrimitive } from "../functions/weld.3.js";
-import { calculateMeshDensity } from "../utils/mesh.js";
-import { isMeshLOD } from "./needle_progressive.js";
-const NAME = 'needle_mesh_transform';
-/**
- * Which compression type for a model should be used. This should be respected when creating LOD meshes and the appropriate extension should be added to the LOD mesh so it receives the same mesh compression as the parent mesh
- */
-export function determineMeshCompression(document, filePath) {
-    const rootExtension = document.getRoot().getExtension(NEEDLE_mesh_compression.EXTENSION_NAME);
-    if (rootExtension) {
-        const rootModel = rootExtension.model;
-        if (rootModel) {
-            if (!rootModel.compression) {
-                throw new Error(`[${NAME}]: Invalid mesh compression model extension on root node of ${filePath}`);
-            }
-            return rootModel;
-        }
-    }
-    if (filePath?.toLowerCase().endsWith(".vrm")) {
-        const hasBlendshapes = document.getRoot().listMeshes().some((mesh) => mesh.listPrimitives().some((prim) => prim.listTargets().length > 0));
-        if (hasBlendshapes) {
-            return new NEEDLE_mesh_compression_model_root("meshopt");
-        }
-    }
-    // heuristic to detect if we should choose meshopt over draco
-    // because meshopt can compress blendshapes while draco can not
-    // we currently only consider the vertex count of the blendshapes
-    let sizeOfBlendshapes = 0;
-    let sizeOfMeshes = 0;
-    for (const mesh of document.getRoot().listMeshes()) {
-        for (const prim of mesh.listPrimitives()) {
-            for (const target of prim.listTargets()) {
-                sizeOfBlendshapes += target.getAttribute('POSITION').getArray().length;
-            }
-            sizeOfMeshes += prim.getAttribute('POSITION').getArray().length;
-        }
-    }
-    // TODO: make this more robus with progressive loading: when progressive loading is enabled we need to run this check on the root mesh and enforce the same mesh compression for all children. Until we can do that we can not use the code for choosing compression based on blendshape size
-    if (sizeOfBlendshapes > 0) {
-        document.getLogger().info(`[${NAME}]: will apply meshopt mesh compression because the mesh contains blendshapes`);
-        return new NEEDLE_mesh_compression_model_root("meshopt");
-    }
-    // consider meshopt if blendshape size is > 256 KB
-    // const sizeThreshold = 256 * 1024;
-    // if (sizeOfBlendshapes > sizeThreshold) {
-    //     /** How big are the blendshapes compared to the overall mesh size */
-    //     const blendshapeRatio = sizeOfBlendshapes / sizeOfMeshes;
-    //     /** 25% of the size are blendshapres */
-    //     const ratioThreshold = 0.1;
-    //     if (blendshapeRatio >= ratioThreshold) {
-    //         document.getLogger().info(`[${NAME}]: will apply meshopt mesh compression because blendshapes are ${(blendshapeRatio * 100).toFixed(2)}% of the mesh size`);
-    //         const transform = meshopt({ encoder: MeshoptEncoder });
-    //         return transform(document, transform_context);
-    //     }
-    // }
-    return new NEEDLE_mesh_compression_model_root("draco");
-}
-export const needle_mesh_transform = function (context) {
-    return async (document, _context) => {
-        // TODO: needs to be moved into NEEDLE_progressive
-        await simplifierTransform(document, _context, context);
-        await applyMeshCompression(document, _context, context);
-    };
-};
-async function applyMeshCompression(document, transform_context, context) {
-    const isLOD = isMeshLOD(context.file);
-    const compressionModel = determineMeshCompression(document, context.file); // document.getRoot().getExtension(NEEDLE_mesh_compression.EXTENSION_NAME) as NEEDLE_mesh_compression_property;
-    if (compressionModel) {
-        // const rootModel = rootExtension.model as NEEDLE_mesh_compression_model_root;
-        if (compressionModel.compression) {
-            if (compressionModel.compression === "none") {
-                document.getLogger().info(`[${NAME}]: NONE → will not apply mesh compression`);
-                return;
-            }
-            document.getLogger().info(`[${NAME}]: ${compressionModel.compression.toUpperCase()} → will apply ${compressionModel.compression} mesh compression`);
-            if (compressionModel.compression === "draco") {
-                const transform = draco({
-                    encodeSpeed: 8,
-                    decodeSpeed: 8,
-                    quantizationVolume: isLOD ? "scene" : undefined
-                });
-                return transform(document, transform_context);
-            }
-            else if (compressionModel.compression === "meshopt") {
-                const transform = meshopt({ encoder: MeshoptEncoder });
-                return transform(document, transform_context);
-            }
-        }
-    }
-    // by default we still want to run draco if the root doesnt have a compression model configured
-    document.getLogger().info(`[${NAME}]: → will apply draco mesh compression (default)`);
-    const transform = draco({
-        encodeSpeed: 8,
-        decodeSpeed: 8,
-        quantizationVolume: isLOD ? "scene" : undefined
-    });
-    return transform(document, transform_context);
-}
-async function simplifierTransform(document, _context, meshContext) {
-    const simplifier = MeshoptSimplifier;
-    if (!simplifier) {
-        console.log(`WARN: [${NAME}] simplifier dependency required — install "meshoptimizer".`);
-        return false;
-    }
-    const logger = document.getLogger();
-    const isVRM = meshContext.file?.toLowerCase().endsWith(".vrm");
-    const options = {
-        ...SIMPLIFY_DEFAULTS,
-        simplifier: simplifier,
-        ratio: 0.75,
-        error: 0.0005,
-    };
-    const weldOptions = {
-        ...WELD_DEFAULTS,
-        overwrite: true,
-    };
-    // let meshInformation: MeshInformation | null = null;
-    // if (isVRM) {
-    //     meshInformation = getMeshInformation(document);
-    // }
-    for (const mesh of document.getRoot().listMeshes()) {
-        let i = 0;
-        for (const prim of mesh.listPrimitives()) {
-            const index = i++;
-            // TODO: mesh compression caching
-            // 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);
-            const mesh_compression = ext?.model;
-            const simplifyOpts = { ...options };
-            if (isVRM) {
-                const density = calculateMeshDensity(prim);
-                if (density > 0) {
-                    const targetDensity = 2_000;
-                    const t = (1 / density) * targetDensity;
-                    simplifyOpts.ratio = Math.min(Math.max(.1, t), .95);
-                    simplifyOpts.error = 15 / density;
-                    simplifyOpts.lockBorder = true;
-                }
-                else {
-                    simplifyOpts.ratio = 0.8;
-                    simplifyOpts.error = 0.001;
-                    simplifyOpts.lockBorder = true;
-                }
-                logger.info(`${mesh.getName()}: Density: ${density.toFixed(2)}, Ratio: ${simplifyOpts.ratio.toFixed(2)}, Error: ${simplifyOpts.error}`);
-            }
-            if (!ext && !isVRM) {
-                // If no extension exists on the primitive dont apply any simplification
-                // AND if the file is not a VRM file
-                continue;
-            }
-            if (mesh_compression) {
-                // Dont run if useSimplifier is turned off explictly
-                if (mesh_compression.useSimplifier === false) {
-                    logger.debug(`[${NAME}]: Skipping primitive of mesh "${mesh.getName()}": useSimplifier is false.`);
-                    continue;
-                }
-                if (mesh_compression.error >= 0)
-                    simplifyOpts.error = mesh_compression.error;
-                if (mesh_compression.ratio >= 0)
-                    simplifyOpts.ratio = mesh_compression.ratio;
-                simplifyOpts.lockBorder = mesh_compression.lockBorder;
-            }
-            if (prim.getMode() !== Primitive.Mode.TRIANGLES) {
-                logger.warn(`[${NAME}]: Skipping primitive of mesh "${mesh.getName()}": Requires TRIANGLES draw mode.`);
-                continue;
-            }
-            compressPrimitive(document, mesh, prim, index, weldOptions, simplifyOpts);
-        }
-    }
-    return true;
-}
-export async function compressPrimitive(document, mesh, prim, index, weldOptions, meshOptions) {
-    const logger = document.getLogger();
-    logger.debug(`weld: primitive[${index}] of mesh "${mesh.getName()}"`);
-    weldPrimitive(prim, weldOptions);
-    // make sure we wait for the mesh simplifier to be ready
-    if (meshOptions.simplifier && meshOptions.simplifier?.ready instanceof Promise) {
-        const res = await meshOptions.simplifier?.ready
-            .then(() => {
-            // ready!
-            return true;
-        })
-            .catch((err) => {
-            console.error(`[${NAME}]: Simplifier failed to load...\n${err}`);
-            return false;
-        });
-        if (!res)
-            return;
-    }
-    // TODO: enable regularize once it's available: https://github.com/zeux/meshoptimizer/pull/914/files
-    logger.debug(`simplify: primitive[${index}] of mesh "${mesh.getName()}" → ratio: ${meshOptions.ratio}, error: ${meshOptions.error}, lockBorder: ${meshOptions.lockBorder}, regularize: ${meshOptions.regularize}, normalWeight: ${meshOptions.normalWeight}, colorWeight: ${meshOptions.colorWeight}, textureWeight: ${meshOptions.textureWeight}`);
-    return simplifyPrimitive(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();
-// }
+import { Primitive } from "@gltf-transform/core";
+import { meshopt, simplifyPrimitive, SIMPLIFY_DEFAULTS, WELD_DEFAULTS, draco } from "@gltf-transform/functions";
+import { MeshoptEncoder, MeshoptSimplifier } from "meshoptimizer";
+import { NEEDLE_mesh_compression, NEEDLE_mesh_compression_model_root } from "../extensions/index.js";
+import { weldPrimitive } from "../functions/weld.3.js";
+import { calculateMeshDensity } from "../utils/mesh.js";
+import { isMeshLOD } from "./needle_progressive.js";
+const NAME = 'needle_mesh_transform';
+/**
+ * Which compression type for a model should be used. This should be respected when creating LOD meshes and the appropriate extension should be added to the LOD mesh so it receives the same mesh compression as the parent mesh
+ */
+export function determineMeshCompression(document, filePath) {
+    const rootExtension = document.getRoot().getExtension(NEEDLE_mesh_compression.EXTENSION_NAME);
+    if (rootExtension) {
+        const rootModel = rootExtension.model;
+        if (rootModel) {
+            if (!rootModel.compression) {
+                throw new Error(`[${NAME}]: Invalid mesh compression model extension on root node of ${filePath}`);
+            }
+            return rootModel;
+        }
+    }
+    if (filePath?.toLowerCase().endsWith(".vrm")) {
+        const hasBlendshapes = document.getRoot().listMeshes().some((mesh) => mesh.listPrimitives().some((prim) => prim.listTargets().length > 0));
+        if (hasBlendshapes) {
+            return new NEEDLE_mesh_compression_model_root("meshopt");
+        }
+    }
+    // heuristic to detect if we should choose meshopt over draco
+    // because meshopt can compress blendshapes while draco can not
+    // we currently only consider the vertex count of the blendshapes
+    let sizeOfBlendshapes = 0;
+    let sizeOfMeshes = 0;
+    for (const mesh of document.getRoot().listMeshes()) {
+        for (const prim of mesh.listPrimitives()) {
+            for (const target of prim.listTargets()) {
+                sizeOfBlendshapes += target.getAttribute('POSITION').getArray().length;
+            }
+            sizeOfMeshes += prim.getAttribute('POSITION').getArray().length;
+        }
+    }
+    // TODO: make this more robus with progressive loading: when progressive loading is enabled we need to run this check on the root mesh and enforce the same mesh compression for all children. Until we can do that we can not use the code for choosing compression based on blendshape size
+    if (sizeOfBlendshapes > 0) {
+        document.getLogger().info(`[${NAME}]: will apply meshopt mesh compression because the mesh contains blendshapes`);
+        return new NEEDLE_mesh_compression_model_root("meshopt");
+    }
+    // consider meshopt if blendshape size is > 256 KB
+    // const sizeThreshold = 256 * 1024;
+    // if (sizeOfBlendshapes > sizeThreshold) {
+    //     /** How big are the blendshapes compared to the overall mesh size */
+    //     const blendshapeRatio = sizeOfBlendshapes / sizeOfMeshes;
+    //     /** 25% of the size are blendshapres */
+    //     const ratioThreshold = 0.1;
+    //     if (blendshapeRatio >= ratioThreshold) {
+    //         document.getLogger().info(`[${NAME}]: will apply meshopt mesh compression because blendshapes are ${(blendshapeRatio * 100).toFixed(2)}% of the mesh size`);
+    //         const transform = meshopt({ encoder: MeshoptEncoder });
+    //         return transform(document, transform_context);
+    //     }
+    // }
+    return new NEEDLE_mesh_compression_model_root("draco");
+}
+export const needle_mesh_transform = function (context) {
+    return async (document, _context) => {
+        // TODO: needs to be moved into NEEDLE_progressive
+        await simplifierTransform(document, _context, context);
+        await applyMeshCompression(document, _context, context);
+    };
+};
+async function applyMeshCompression(document, transform_context, context) {
+    const isLOD = isMeshLOD(context.file);
+    const compressionModel = determineMeshCompression(document, context.file); // document.getRoot().getExtension(NEEDLE_mesh_compression.EXTENSION_NAME) as NEEDLE_mesh_compression_property;
+    if (compressionModel) {
+        // const rootModel = rootExtension.model as NEEDLE_mesh_compression_model_root;
+        if (compressionModel.compression) {
+            if (compressionModel.compression === "none") {
+                document.getLogger().info(`[${NAME}]: NONE → will not apply mesh compression`);
+                return;
+            }
+            document.getLogger().info(`[${NAME}]: ${compressionModel.compression.toUpperCase()} → will apply ${compressionModel.compression} mesh compression`);
+            if (compressionModel.compression === "draco") {
+                const transform = draco({
+                    encodeSpeed: 8,
+                    decodeSpeed: 8,
+                    quantizationVolume: isLOD ? "scene" : undefined
+                });
+                return transform(document, transform_context);
+            }
+            else if (compressionModel.compression === "meshopt") {
+                const transform = meshopt({ encoder: MeshoptEncoder });
+                return transform(document, transform_context);
+            }
+        }
+    }
+    // by default we still want to run draco if the root doesnt have a compression model configured
+    document.getLogger().info(`[${NAME}]: → will apply draco mesh compression (default)`);
+    const transform = draco({
+        encodeSpeed: 8,
+        decodeSpeed: 8,
+        quantizationVolume: isLOD ? "scene" : undefined
+    });
+    return transform(document, transform_context);
+}
+async function simplifierTransform(document, _context, meshContext) {
+    const simplifier = MeshoptSimplifier;
+    if (!simplifier) {
+        console.log(`WARN: [${NAME}] simplifier dependency required — install "meshoptimizer".`);
+        return false;
+    }
+    const logger = document.getLogger();
+    const isVRM = meshContext.file?.toLowerCase().endsWith(".vrm");
+    const options = {
+        ...SIMPLIFY_DEFAULTS,
+        simplifier: simplifier,
+        ratio: 0.75,
+        error: 0.0005,
+    };
+    const weldOptions = {
+        ...WELD_DEFAULTS,
+        overwrite: true,
+    };
+    // let meshInformation: MeshInformation | null = null;
+    // if (isVRM) {
+    //     meshInformation = getMeshInformation(document);
+    // }
+    for (const mesh of document.getRoot().listMeshes()) {
+        let i = 0;
+        for (const prim of mesh.listPrimitives()) {
+            const index = i++;
+            // TODO: mesh compression caching
+            // 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);
+            const mesh_compression = ext?.model;
+            const simplifyOpts = { ...options };
+            if (isVRM) {
+                const density = calculateMeshDensity(prim);
+                if (density > 0) {
+                    const targetDensity = 2_000;
+                    const t = (1 / density) * targetDensity;
+                    simplifyOpts.ratio = Math.min(Math.max(.1, t), .95);
+                    simplifyOpts.error = 15 / density;
+                    simplifyOpts.lockBorder = true;
+                }
+                else {
+                    simplifyOpts.ratio = 0.8;
+                    simplifyOpts.error = 0.001;
+                    simplifyOpts.lockBorder = true;
+                }
+                logger.info(`${mesh.getName()}: Density: ${density.toFixed(2)}, Ratio: ${simplifyOpts.ratio.toFixed(2)}, Error: ${simplifyOpts.error}`);
+            }
+            if (!ext && !isVRM) {
+                // If no extension exists on the primitive dont apply any simplification
+                // AND if the file is not a VRM file
+                continue;
+            }
+            if (mesh_compression) {
+                // Dont run if useSimplifier is turned off explictly
+                if (mesh_compression.useSimplifier === false) {
+                    logger.debug(`[${NAME}]: Skipping primitive of mesh "${mesh.getName()}": useSimplifier is false.`);
+                    continue;
+                }
+                if (mesh_compression.error >= 0)
+                    simplifyOpts.error = mesh_compression.error;
+                if (mesh_compression.ratio >= 0)
+                    simplifyOpts.ratio = mesh_compression.ratio;
+                simplifyOpts.lockBorder = mesh_compression.lockBorder;
+            }
+            if (prim.getMode() !== Primitive.Mode.TRIANGLES) {
+                logger.warn(`[${NAME}]: Skipping primitive of mesh "${mesh.getName()}": Requires TRIANGLES draw mode.`);
+                continue;
+            }
+            compressPrimitive(document, mesh, prim, index, weldOptions, simplifyOpts);
+        }
+    }
+    return true;
+}
+export async function compressPrimitive(document, mesh, prim, index, weldOptions, meshOptions) {
+    const logger = document.getLogger();
+    logger.debug(`weld: primitive[${index}] of mesh "${mesh.getName()}"`);
+    weldPrimitive(prim, weldOptions);
+    // make sure we wait for the mesh simplifier to be ready
+    if (meshOptions.simplifier && meshOptions.simplifier?.ready instanceof Promise) {
+        const res = await meshOptions.simplifier?.ready
+            .then(() => {
+            // ready!
+            return true;
+        })
+            .catch((err) => {
+            console.error(`[${NAME}]: Simplifier failed to load...\n${err}`);
+            return false;
+        });
+        if (!res)
+            return;
+    }
+    // TODO: enable regularize once it's available: https://github.com/zeux/meshoptimizer/pull/914/files
+    logger.debug(`simplify: primitive[${index}] of mesh "${mesh.getName()}" → ratio: ${meshOptions.ratio}, error: ${meshOptions.error}, lockBorder: ${meshOptions.lockBorder}, regularize: ${meshOptions.regularize}, normalWeight: ${meshOptions.normalWeight}, colorWeight: ${meshOptions.colorWeight}, textureWeight: ${meshOptions.textureWeight}`);
+    return simplifyPrimitive(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_progressive.d.ts

@@ -1,45 +1,45 @@
-import { ILogger, Texture, Transform, vec2 } from '@gltf-transform/core';
-import { Config } from '../config/index.js';
-declare interface ProgressiveOptions {
-    path: string | Array<string>;
-    /** Directory to output progressive assets to */
-    outpath?: string;
-    results: Array<string>;
-    config: Config;
-    debug?: boolean;
-    verbose?: boolean;
-    useCache?: boolean;
-    logger: ILogger;
-}
-export declare function make_progressive(opts: ProgressiveOptions): Promise<boolean>;
-export declare function createTransform(name: string, fn: Transform): Transform;
-export declare function make_progressive_textures(filePath: string, _options: TextureResizeOptions, opts: ProgressiveOptions): Transform;
-/** Options for the {@link textureResize} function. */
-export interface TextureResizeOptions {
-    /**
-     * Maximum width/height to enforce, preserving aspect ratio. For example,
-     * a 4096x8192 texture, resized with limit [2048, 2048] will be reduced
-     * to 1024x2048.
-     */
-    size: vec2;
-    /** Resampling filter method. LANCZOS3 is sharper, LANCZOS2 is smoother. */
-    filter?: TextureResizeFilter;
-    /** Pattern identifying textures to resize, matched to name or URI. */
-    pattern?: RegExp | null;
-    /** Pattern to match slots usage for resizing. */
-    slots?: RegExp | null;
-}
-/** Resampling filter methods. LANCZOS3 is sharper, LANCZOS2 is smoother. */
-export declare enum TextureResizeFilter {
-    /** Lanczos3 (sharp) */
-    LANCZOS3 = "lanczos3",
-    /** Lanczos2 (smooth) */
-    LANCZOS2 = "lanczos2"
-}
-export declare const TEXTURE_RESIZE_DEFAULTS: TextureResizeOptions;
-export declare function resizeTextureToMax(texture: Texture, maxSize: number, logger: ILogger): Promise<void>;
-export declare function make_progressive_meshes(filePath: string, _options: any, opts?: ProgressiveOptions): Transform;
-export declare function isMeshLOD(filepath: string): boolean;
-export declare function isImageLOD(filepath: string): boolean;
-export declare function isLOD(filepath: string): boolean;
-export {};
+import { ILogger, Texture, Transform, vec2 } from '@gltf-transform/core';
+import { Config } from '../config/index.js';
+declare interface ProgressiveOptions {
+    path: string | Array<string>;
+    /** Directory to output progressive assets to */
+    outpath?: string;
+    results: Array<string>;
+    config: Config;
+    debug?: boolean;
+    verbose?: boolean;
+    useCache?: boolean;
+    logger: ILogger;
+}
+export declare function make_progressive(opts: ProgressiveOptions): Promise<boolean>;
+export declare function createTransform(name: string, fn: Transform): Transform;
+export declare function make_progressive_textures(filePath: string, _options: TextureResizeOptions, opts: ProgressiveOptions): Transform;
+/** Options for the {@link textureResize} function. */
+export interface TextureResizeOptions {
+    /**
+     * Maximum width/height to enforce, preserving aspect ratio. For example,
+     * a 4096x8192 texture, resized with limit [2048, 2048] will be reduced
+     * to 1024x2048.
+     */
+    size: vec2;
+    /** Resampling filter method. LANCZOS3 is sharper, LANCZOS2 is smoother. */
+    filter?: TextureResizeFilter;
+    /** Pattern identifying textures to resize, matched to name or URI. */
+    pattern?: RegExp | null;
+    /** Pattern to match slots usage for resizing. */
+    slots?: RegExp | null;
+}
+/** Resampling filter methods. LANCZOS3 is sharper, LANCZOS2 is smoother. */
+export declare enum TextureResizeFilter {
+    /** Lanczos3 (sharp) */
+    LANCZOS3 = "lanczos3",
+    /** Lanczos2 (smooth) */
+    LANCZOS2 = "lanczos2"
+}
+export declare const TEXTURE_RESIZE_DEFAULTS: TextureResizeOptions;
+export declare function resizeTextureToMax(texture: Texture, maxSize: number, logger: ILogger): Promise<void>;
+export declare function make_progressive_meshes(filePath: string, _options: any, opts?: ProgressiveOptions): Transform;
+export declare function isMeshLOD(filepath: string): boolean;
+export declare function isImageLOD(filepath: string): boolean;
+export declare function isLOD(filepath: string): boolean;
+export {};