@needle-tools/gltf-build-pipeline 2.2.1-alpha.2 → 2.2.1-alpha.4

package/dist/transforms/needle_mesh_transform.js

@@ -1,140 +1,140 @@
-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 } from "../extensions/index.js";
-import { weldPrimitive } from "../functions/weld.3.js";
-const NAME = 'needle_mesh_transform';
-export const needle_mesh_transform = function (context, simplify) {
-    return async (document, _context) => {
-        // TODO: needs to be moved into NEEDLE_progressive
-        await simplifierTransform(document, _context, simplify);
-        await applyMeshCompression(document, _context, context);
-    };
-};
-async function applyMeshCompression(document, transform_context, context) {
-    const rootExtension = document.getRoot().getExtension(NEEDLE_mesh_compression.EXTENSION_NAME);
-    if (rootExtension) {
-        const rootModel = rootExtension.model;
-        if (rootModel.compression) {
-            if (rootModel.compression === "none") {
-                document.getLogger().info(`[${NAME}]: NONE → will not apply mesh compression`);
-                return;
-            }
-            document.getLogger().info(`[${NAME}]: ${rootModel.compression.toUpperCase()} → will apply ${rootModel.compression} mesh compression`);
-            if (rootModel.compression === "draco") {
-                const transform = draco();
-                return transform(document, transform_context);
-            }
-            else if (rootModel.compression === "meshopt") {
-                const transform = meshopt({ encoder: MeshoptEncoder });
-                return transform(document, transform_context);
-            }
-        }
-    }
-    // If nothing is configured apply meshopt compression as long as we're running gltf-transform 3.x
-    // if (context.file.endsWith(".vrm")) {
-    //     document.getLogger().info(`[${NAME}]: VRM → will apply meshopt mesh compression`);
-    //     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)`);
-    return draco()(document, transform_context);
-}
-async function simplifierTransform(document, _context, _options) {
-    const simplifier = MeshoptSimplifier;
-    if (!simplifier) {
-        console.log(`WARN: [${NAME}] simplifier dependency required — install "meshoptimizer".`);
-        return false;
-    }
-    const logger = document.getLogger();
-    const options = { ...SIMPLIFY_DEFAULTS, ..._options };
-    if (!options.simplifier)
-        options.simplifier = simplifier;
-    const weldOptions = {
-        ...WELD_DEFAULTS,
-        tolerance: 0.00000000001,
-        overwrite: true,
-    };
-    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 (!ext) {
-                // If no extension exists on the primitive dont apply any simplification
-                // console.log(`[${NAME}]: Skipping primitive simplification of mesh "${mesh.getName()}": No mesh compression extension found.`);
-                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;
-    }
-    logger.debug(`simplify: primitive[${index}] of mesh "${mesh.getName()}" → ratio: ${meshOptions.ratio}, error: ${meshOptions.error}, lockBorder: ${meshOptions.lockBorder}`);
-    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 } from "../extensions/index.js";
+import { weldPrimitive } from "../functions/weld.3.js";
+const NAME = 'needle_mesh_transform';
+export const needle_mesh_transform = function (context, simplify) {
+    return async (document, _context) => {
+        // TODO: needs to be moved into NEEDLE_progressive
+        await simplifierTransform(document, _context, simplify);
+        await applyMeshCompression(document, _context, context);
+    };
+};
+async function applyMeshCompression(document, transform_context, context) {
+    const rootExtension = document.getRoot().getExtension(NEEDLE_mesh_compression.EXTENSION_NAME);
+    if (rootExtension) {
+        const rootModel = rootExtension.model;
+        if (rootModel.compression) {
+            if (rootModel.compression === "none") {
+                document.getLogger().info(`[${NAME}]: NONE → will not apply mesh compression`);
+                return;
+            }
+            document.getLogger().info(`[${NAME}]: ${rootModel.compression.toUpperCase()} → will apply ${rootModel.compression} mesh compression`);
+            if (rootModel.compression === "draco") {
+                const transform = draco();
+                return transform(document, transform_context);
+            }
+            else if (rootModel.compression === "meshopt") {
+                const transform = meshopt({ encoder: MeshoptEncoder });
+                return transform(document, transform_context);
+            }
+        }
+    }
+    // If nothing is configured apply meshopt compression as long as we're running gltf-transform 3.x
+    // if (context.file.endsWith(".vrm")) {
+    //     document.getLogger().info(`[${NAME}]: VRM → will apply meshopt mesh compression`);
+    //     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)`);
+    return draco()(document, transform_context);
+}
+async function simplifierTransform(document, _context, _options) {
+    const simplifier = MeshoptSimplifier;
+    if (!simplifier) {
+        console.log(`WARN: [${NAME}] simplifier dependency required — install "meshoptimizer".`);
+        return false;
+    }
+    const logger = document.getLogger();
+    const options = { ...SIMPLIFY_DEFAULTS, ..._options };
+    if (!options.simplifier)
+        options.simplifier = simplifier;
+    const weldOptions = {
+        ...WELD_DEFAULTS,
+        tolerance: 0.00000000001,
+        overwrite: true,
+    };
+    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 (!ext) {
+                // If no extension exists on the primitive dont apply any simplification
+                // console.log(`[${NAME}]: Skipping primitive simplification of mesh "${mesh.getName()}": No mesh compression extension found.`);
+                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;
+    }
+    logger.debug(`simplify: primitive[${index}] of mesh "${mesh.getName()}" → ratio: ${meshOptions.ratio}, error: ${meshOptions.error}, lockBorder: ${meshOptions.lockBorder}`);
+    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,42 +1,42 @@
-import { ILogger, Texture, Transform, vec2 } from '@gltf-transform/core';
-import { Config } from '../config/index.js';
-declare interface ProgressiveOptions {
-    path: string | Array<string>;
-    results: Array<string>;
-    config: Config;
-    debug?: boolean;
-    verbose?: boolean;
-    useCache?: boolean;
-}
-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>;
+    results: Array<string>;
+    config: Config;
+    debug?: boolean;
+    verbose?: boolean;
+    useCache?: boolean;
+}
+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 {};