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

package/dist/index.d.ts

@@ -1,8 +1,8 @@
-export * from "./config/index.js";
-export * from "./cli/index.js";
-export * from "./utils/index.js";
-export * from "./transforms/index.js";
-export * from "./extensions/index.js";
-export * from "./cache/index.js";
-export * from "./scripts/index.js";
-export * from "./constants.js";
+export * from "./config/index.js";
+export * from "./cli/index.js";
+export * from "./utils/index.js";
+export * from "./transforms/index.js";
+export * from "./extensions/index.js";
+export * from "./cache/index.js";
+export * from "./scripts/index.js";
+export * from "./constants.js";

package/dist/index.js

@@ -1,8 +1,8 @@
-export * from "./config/index.js";
-export * from "./cli/index.js";
-export * from "./utils/index.js";
-export * from "./transforms/index.js";
-export * from "./extensions/index.js";
-export * from "./cache/index.js";
-export * from "./scripts/index.js";
-export * from "./constants.js";
+export * from "./config/index.js";
+export * from "./cli/index.js";
+export * from "./utils/index.js";
+export * from "./transforms/index.js";
+export * from "./extensions/index.js";
+export * from "./cache/index.js";
+export * from "./scripts/index.js";
+export * from "./constants.js";

package/dist/scripts/index.d.ts

@@ -1,2 +1,2 @@
-export * from "./pack-gltf.js";
-export * from "./stats.js";
+export * from "./pack-gltf.js";
+export * from "./stats.js";

package/dist/scripts/index.js

@@ -1,2 +1,2 @@
-export * from "./pack-gltf.js";
-export * from "./stats.js";
+export * from "./pack-gltf.js";
+export * from "./stats.js";

package/dist/scripts/pack-gltf.d.ts

@@ -1,16 +1,16 @@
-import { ILogger } from '@gltf-transform/core';
-import { FileStats, ProcessStats } from "../utils/index.js";
-import { Config } from '../config/index.js';
-export type PackGLTFOptions = {
-    useCache: boolean;
-    packedFiles?: Set<string>;
-    stats?: ProcessStats;
-    file_stats: FileStats[] | null;
-    config: Config;
-    logger?: ILogger;
-    debug: boolean;
-    verbose?: boolean;
-};
-/** Compress a glTF file
- */
-export declare function packGLTF(inputFile: string, outputFile: string, options: PackGLTFOptions): Promise<boolean>;
+import { ILogger } from '@gltf-transform/core';
+import { FileStats, ProcessStats } from "../utils/index.js";
+import { Config } from '../config/index.js';
+export type PackGLTFOptions = {
+    useCache: boolean;
+    packedFiles?: Set<string>;
+    stats?: ProcessStats;
+    file_stats: FileStats[] | null;
+    config: Config;
+    logger?: ILogger;
+    debug: boolean;
+    verbose?: boolean;
+};
+/** Compress a glTF file
+ */
+export declare function packGLTF(inputFile: string, outputFile: string, options: PackGLTFOptions): Promise<boolean>;

package/dist/scripts/pack-gltf.js

@@ -1,120 +1,120 @@
-import path from 'path';
-import { Logger, NodeIO, PropertyType, Verbosity } from '@gltf-transform/core';
-import { ALL_EXTENSIONS } from '@gltf-transform/extensions';
-import draco3d from 'draco3dgltf';
-import { existsSync, readFileSync, statSync, writeFileSync } from 'fs';
-import { MeshoptDecoder, MeshoptEncoder } from 'meshoptimizer';
-import { dedup, prune, resample } from '@gltf-transform/functions';
-import { ALL_EXTENSIONS as NEEDLE_EXTENSIONS, NEEDLE_compression_texture, NEEDLE_mesh_compression, } from '../extensions/index.js';
-import { isLOD, isMeshLOD, needle_animation_transform, needle_asset, needle_mesh_transform, needle_texture_transform, } from '../transforms/index.js';
-import { createNewFilestats, writeNodeIO } from "../utils/index.js";
-import { addToCache, getHash, tryGetFromCache, } from "../cache/index.js";
-/** Compress a glTF file
- */
-export async function packGLTF(inputFile, outputFile, options) {
-    if (!options.logger) {
-        options.logger = new Logger(Verbosity.INFO);
-    }
-    const { debug, stats, packedFiles, useCache, logger } = options;
-    if (!existsSync(inputFile)) {
-        logger.error("WARN: can not pack, file does not exist: " + inputFile);
-        return false;
-    }
-    // check if it's in the cache. 
-    // We only need to check mesh LOD files because image LODs are cache via our toktx transform
-    // We can not cache the main glTF files because the hash always changes for them
-    let cacheKey = undefined;
-    if (useCache && isMeshLOD(inputFile)) {
-        const existing = readFileSync(inputFile);
-        const hash = getHash(existing);
-        cacheKey = "packed-" + hash;
-        const cached = tryGetFromCache(cacheKey);
-        if (cached) {
-            logger.info(`→ Loaded compressed file from cache: \"${path.basename(inputFile)}\"`);
-            writeFileSync(inputFile, cached);
-            return true;
-        }
-    }
-    if (packedFiles) {
-        if (packedFiles.has(inputFile))
-            return true;
-        packedFiles.add(inputFile);
-    }
-    try {
-        const config = options.config;
-        const prevSizeInMB = statSync(inputFile).size / 1024 / 1024;
-        logger.info(`→ Compressing ${prevSizeInMB.toFixed(1)} MB: ${inputFile}`);
-        const startTime = Date.now();
-        const io = new NodeIO()
-            .registerExtensions(ALL_EXTENSIONS)
-            .registerExtensions(NEEDLE_EXTENSIONS)
-            .registerExtensions([
-            NEEDLE_compression_texture,
-            NEEDLE_mesh_compression,
-        ])
-            .registerDependencies({
-            'draco3d.decoder': await draco3d.createDecoderModule(),
-            'draco3d.encoder': await draco3d.createEncoderModule(),
-            'meshopt.decoder': MeshoptDecoder,
-            'meshopt.encoder': MeshoptEncoder,
-        });
-        const document = await io.read(inputFile);
-        /** @ts-ignore */
-        document.getLogger().verbosity = options.debug || options.verbose ? Verbosity.DEBUG : Verbosity.WARN;
-        let totalGPUTextureMemory = 0;
-        /** @type {Array<import('@gltf-transform/core').Transform>} */
-        const transforms = [
-            needle_asset(),
-            needle_texture_transform({
-                file: inputFile,
-                useCache,
-                noToktx: false,
-                debug: debug,
-                reportGPUMemory: val => {
-                    totalGPUTextureMemory += val;
-                },
-                config,
-            }),
-            needle_mesh_transform({ file: inputFile, config }, { ratio: 0.75, error: 0.0005 }),
-            needle_animation_transform({}),
-            resample(),
-            // Can not dedup "materials" because progressive textures will then assigned to the wrong material instance
-            dedup({ propertyTypes: [PropertyType.MESH, PropertyType.MATERIAL] }),
-            // prune(),
-        ];
-        const isProgressiveAsset = isLOD(inputFile);
-        // TODO: progressive mesh LODs should not be pruned right now because it will remove e.g. UVs from meshes (and probably blend shapes too) (so we just not do it for any progressive asset) 
-        if (!isProgressiveAsset) {
-            transforms.push(prune({
-                // Pruning animations is not supported yet (e.g. if the animation is only referenced by a component)
-                propertyTypes: ['MESH', 'MATERIAL', 'TEXTURE']
-            }));
-        }
-        await document.transform(...transforms);
-        if (!outputFile)
-            outputFile = inputFile;
-        await writeNodeIO(io, outputFile, document);
-        if (useCache && cacheKey != undefined && existsSync(outputFile))
-            addToCache(cacheKey, readFileSync(outputFile));
-        const duration = Date.now() - startTime;
-        const sizeInMB = statSync(outputFile).size / 1024 / 1024;
-        const filename = path.basename(outputFile);
-        const gpuMemoryInMB = totalGPUTextureMemory / 1024 / 1024;
-        logger.info(`← Compressing done in ${(duration / 1000).toFixed(1)} sec, ${prevSizeInMB.toFixed(1)} MB → ${sizeInMB.toFixed(1)} MB (GPU: ${gpuMemoryInMB.toFixed(1)} MB textures): ${filename} at ${outputFile}`);
-        if (stats) {
-            stats.totalFilesProcessed++;
-            stats.totalFileSizeInMB += sizeInMB;
-            stats.totalFileSizeInMBBefore += prevSizeInMB;
-            stats.totalGPUMemoryInMB += gpuMemoryInMB;
-        }
-        const filestats = createNewFilestats(outputFile, document);
-        options.file_stats?.push(filestats);
-        return true;
-    }
-    catch (err) {
-        logger.error(`packing ${path.basename(inputFile)} failed: ${err}`);
-        if (debug)
-            throw err;
-        return false;
-    }
-}
+import path from 'path';
+import { Logger, NodeIO, PropertyType, Verbosity } from '@gltf-transform/core';
+import { ALL_EXTENSIONS } from '@gltf-transform/extensions';
+import draco3d from 'draco3dgltf';
+import { existsSync, readFileSync, statSync, writeFileSync } from 'fs';
+import { MeshoptDecoder, MeshoptEncoder } from 'meshoptimizer';
+import { dedup, prune, resample } from '@gltf-transform/functions';
+import { ALL_EXTENSIONS as NEEDLE_EXTENSIONS, NEEDLE_compression_texture, NEEDLE_mesh_compression, } from '../extensions/index.js';
+import { isLOD, isMeshLOD, needle_animation_transform, needle_asset, needle_mesh_transform, needle_texture_transform, } from '../transforms/index.js';
+import { createNewFilestats, writeNodeIO } from "../utils/index.js";
+import { addToCache, getHash, tryGetFromCache, } from "../cache/index.js";
+/** Compress a glTF file
+ */
+export async function packGLTF(inputFile, outputFile, options) {
+    if (!options.logger) {
+        options.logger = new Logger(Verbosity.INFO);
+    }
+    const { debug, stats, packedFiles, useCache, logger } = options;
+    if (!existsSync(inputFile)) {
+        logger.error("WARN: can not pack, file does not exist: " + inputFile);
+        return false;
+    }
+    // check if it's in the cache. 
+    // We only need to check mesh LOD files because image LODs are cache via our toktx transform
+    // We can not cache the main glTF files because the hash always changes for them
+    let cacheKey = undefined;
+    if (useCache && isMeshLOD(inputFile)) {
+        const existing = readFileSync(inputFile);
+        const hash = getHash(existing);
+        cacheKey = "packed-" + hash;
+        const cached = tryGetFromCache(cacheKey);
+        if (cached) {
+            logger.info(`→ Loaded compressed file from cache: \"${path.basename(inputFile)}\"`);
+            writeFileSync(inputFile, cached);
+            return true;
+        }
+    }
+    if (packedFiles) {
+        if (packedFiles.has(inputFile))
+            return true;
+        packedFiles.add(inputFile);
+    }
+    try {
+        const config = options.config;
+        const prevSizeInMB = statSync(inputFile).size / 1024 / 1024;
+        logger.info(`→ Compressing ${prevSizeInMB.toFixed(1)} MB: ${inputFile}`);
+        const startTime = Date.now();
+        const io = new NodeIO()
+            .registerExtensions(ALL_EXTENSIONS)
+            .registerExtensions(NEEDLE_EXTENSIONS)
+            .registerExtensions([
+            NEEDLE_compression_texture,
+            NEEDLE_mesh_compression,
+        ])
+            .registerDependencies({
+            'draco3d.decoder': await draco3d.createDecoderModule(),
+            'draco3d.encoder': await draco3d.createEncoderModule(),
+            'meshopt.decoder': MeshoptDecoder,
+            'meshopt.encoder': MeshoptEncoder,
+        });
+        const document = await io.read(inputFile);
+        /** @ts-ignore */
+        document.getLogger().verbosity = options.debug || options.verbose ? Verbosity.DEBUG : Verbosity.WARN;
+        let totalGPUTextureMemory = 0;
+        /** @type {Array<import('@gltf-transform/core').Transform>} */
+        const transforms = [
+            needle_asset(),
+            needle_texture_transform({
+                file: inputFile,
+                useCache,
+                noToktx: false,
+                debug: debug,
+                reportGPUMemory: val => {
+                    totalGPUTextureMemory += val;
+                },
+                config,
+            }),
+            needle_mesh_transform({ file: inputFile, config }, { ratio: 0.75, error: 0.0005 }),
+            needle_animation_transform({}),
+            resample(),
+            // Can not dedup "materials" because progressive textures will then assigned to the wrong material instance
+            dedup({ propertyTypes: [PropertyType.MESH, PropertyType.MATERIAL] }),
+            // prune(),
+        ];
+        const isProgressiveAsset = isLOD(inputFile);
+        // TODO: progressive mesh LODs should not be pruned right now because it will remove e.g. UVs from meshes (and probably blend shapes too) (so we just not do it for any progressive asset) 
+        if (!isProgressiveAsset) {
+            transforms.push(prune({
+                // Pruning animations is not supported yet (e.g. if the animation is only referenced by a component)
+                propertyTypes: ['MESH', 'MATERIAL', 'TEXTURE']
+            }));
+        }
+        await document.transform(...transforms);
+        if (!outputFile)
+            outputFile = inputFile;
+        await writeNodeIO(io, outputFile, document);
+        if (useCache && cacheKey != undefined && existsSync(outputFile))
+            addToCache(cacheKey, readFileSync(outputFile));
+        const duration = Date.now() - startTime;
+        const sizeInMB = statSync(outputFile).size / 1024 / 1024;
+        const filename = path.basename(outputFile);
+        const gpuMemoryInMB = totalGPUTextureMemory / 1024 / 1024;
+        logger.info(`← Compressing done in ${(duration / 1000).toFixed(1)} sec, ${prevSizeInMB.toFixed(1)} MB → ${sizeInMB.toFixed(1)} MB (GPU: ${gpuMemoryInMB.toFixed(1)} MB textures): ${filename} at ${outputFile}`);
+        if (stats) {
+            stats.totalFilesProcessed++;
+            stats.totalFileSizeInMB += sizeInMB;
+            stats.totalFileSizeInMBBefore += prevSizeInMB;
+            stats.totalGPUMemoryInMB += gpuMemoryInMB;
+        }
+        const filestats = createNewFilestats(outputFile, document);
+        options.file_stats?.push(filestats);
+        return true;
+    }
+    catch (err) {
+        logger.error(`packing ${path.basename(inputFile)} failed: ${err}`);
+        if (debug)
+            throw err;
+        return false;
+    }
+}

package/dist/scripts/stats.d.ts

@@ -1,2 +1,2 @@
-import { FileStats } from "../utils/stats.js";
-export declare function calculateStats(inputfile: string): Promise<FileStats>;
+import { FileStats } from "../utils/stats.js";
+export declare function calculateStats(inputfile: string): Promise<FileStats>;

package/dist/scripts/stats.js

@@ -1,18 +1,18 @@
-import { NodeIO } from "@gltf-transform/core";
-import { ALL_EXTENSIONS } from "@gltf-transform/extensions";
-import draco3d from 'draco3dgltf';
-import { MeshoptDecoder, MeshoptEncoder } from "meshoptimizer";
-import { createNewFilestats } from "../utils/stats.js";
-export async function calculateStats(inputfile) {
-    const io = new NodeIO()
-        .registerExtensions(ALL_EXTENSIONS)
-        .registerDependencies({
-        'draco3d.decoder': await draco3d.createDecoderModule(),
-        'draco3d.encoder': await draco3d.createEncoderModule(),
-        'meshopt.decoder': MeshoptDecoder,
-        'meshopt.encoder': MeshoptEncoder,
-    });
-    const document = await io.read(inputfile);
-    const stats = createNewFilestats(inputfile, document);
-    return stats;
-}
+import { NodeIO } from "@gltf-transform/core";
+import { ALL_EXTENSIONS } from "@gltf-transform/extensions";
+import draco3d from 'draco3dgltf';
+import { MeshoptDecoder, MeshoptEncoder } from "meshoptimizer";
+import { createNewFilestats } from "../utils/stats.js";
+export async function calculateStats(inputfile) {
+    const io = new NodeIO()
+        .registerExtensions(ALL_EXTENSIONS)
+        .registerDependencies({
+        'draco3d.decoder': await draco3d.createDecoderModule(),
+        'draco3d.encoder': await draco3d.createEncoderModule(),
+        'meshopt.decoder': MeshoptDecoder,
+        'meshopt.encoder': MeshoptEncoder,
+    });
+    const document = await io.read(inputfile);
+    const stats = createNewFilestats(inputfile, document);
+    return stats;
+}

package/dist/transforms/index.d.ts

@@ -1,9 +1,9 @@
-export * from "./needle_asset.js";
-export * from "./toktx.js";
-export * from "./needle_toktx.js";
-export * from "./needle_progressive.js";
-export * from "./needle_webp.js";
-export * from "./needle_mesh_transform.js";
-export * from "./needle_common.js";
-export * from "./needle_texture_transform.js";
-export * from "./needle_animation_transform.js";
+export * from "./needle_asset.js";
+export * from "./toktx.js";
+export * from "./needle_toktx.js";
+export * from "./needle_progressive.js";
+export * from "./needle_webp.js";
+export * from "./needle_mesh_transform.js";
+export * from "./needle_common.js";
+export * from "./needle_texture_transform.js";
+export * from "./needle_animation_transform.js";

package/dist/transforms/index.js

@@ -1,9 +1,9 @@
-export * from "./needle_asset.js";
-export * from "./toktx.js";
-export * from "./needle_toktx.js";
-export * from "./needle_progressive.js";
-export * from "./needle_webp.js";
-export * from "./needle_mesh_transform.js";
-export * from "./needle_common.js";
-export * from "./needle_texture_transform.js";
-export * from "./needle_animation_transform.js";
+export * from "./needle_asset.js";
+export * from "./toktx.js";
+export * from "./needle_toktx.js";
+export * from "./needle_progressive.js";
+export * from "./needle_webp.js";
+export * from "./needle_mesh_transform.js";
+export * from "./needle_common.js";
+export * from "./needle_texture_transform.js";
+export * from "./needle_animation_transform.js";

package/dist/transforms/needle_animation_transform.d.ts

@@ -1,2 +1,2 @@
-import { Transform } from "@gltf-transform/core";
-export declare const needle_animation_transform: (_options: any) => Transform;
+import { Transform } from "@gltf-transform/core";
+export declare const needle_animation_transform: (_options: any) => Transform;

package/dist/transforms/needle_animation_transform.js

@@ -1,5 +1,5 @@
-export const needle_animation_transform = function (_options) {
-    // return resample();
-    return (document, _context) => {
-    };
-};
+export const needle_animation_transform = function (_options) {
+    // return resample();
+    return (document, _context) => {
+    };
+};

package/dist/transforms/needle_asset.d.ts

@@ -1,3 +1,3 @@
-import { Document, Transform } from '@gltf-transform/core';
-export declare function writeNeedleAsset(document: Document): void;
-export declare function needle_asset(): Transform;
+import { Document, Transform } from '@gltf-transform/core';
+export declare function writeNeedleAsset(document: Document): void;
+export declare function needle_asset(): Transform;

package/dist/transforms/needle_asset.js

@@ -1,35 +1,35 @@
-import { createTransform } from '@gltf-transform/functions';
-import { getVersion } from '../index.js';
-const generatorName = "Needle Build Pipeline";
-export function writeNeedleAsset(document) {
-    const root = document.getRoot();
-    const asset = root.getAsset();
-    if (asset) {
-        asset.extras = writeNeedleExtras(asset.extras);
-        const version = getVersion();
-        asset.generator = generatorName;
-        if (version?.length > 0) {
-            asset.generator += " " + version;
-        }
-    }
-}
-export function needle_asset() {
-    return createTransform("needle_asset_transform", (document) => {
-        writeNeedleAsset(document);
-    });
-}
-/** @internal */
-function writeNeedleExtras(extras) {
-    if (!extras)
-        extras = {};
-    if (typeof extras === "object" && !extras["needle"]) {
-        let generator = generatorName;
-        const version = getVersion();
-        if (version?.length > 0)
-            generator += " " + version;
-        extras["needle"] = {
-            generator: generator
-        };
-    }
-    return extras;
-}
+import { createTransform } from '@gltf-transform/functions';
+import { getVersion } from '../index.js';
+const generatorName = "Needle Build Pipeline";
+export function writeNeedleAsset(document) {
+    const root = document.getRoot();
+    const asset = root.getAsset();
+    if (asset) {
+        asset.extras = writeNeedleExtras(asset.extras);
+        const version = getVersion();
+        asset.generator = generatorName;
+        if (version?.length > 0) {
+            asset.generator += " " + version;
+        }
+    }
+}
+export function needle_asset() {
+    return createTransform("needle_asset_transform", (document) => {
+        writeNeedleAsset(document);
+    });
+}
+/** @internal */
+function writeNeedleExtras(extras) {
+    if (!extras)
+        extras = {};
+    if (typeof extras === "object" && !extras["needle"]) {
+        let generator = generatorName;
+        const version = getVersion();
+        if (version?.length > 0)
+            generator += " " + version;
+        extras["needle"] = {
+            generator: generator
+        };
+    }
+    return extras;
+}

package/dist/transforms/needle_common.d.ts

@@ -1,16 +1,16 @@
-import { Document, Texture } from '@gltf-transform/core';
-import { NEEDLE_compression_texture_schema } from '../extensions/index.js';
-import { Config } from '../config/index.js';
-export interface NeedleTransformContext {
-    /** full path to the file being processed */
-    file: string;
-    config: Config;
-    debug?: boolean;
-    useCache: boolean;
-    noToktx: boolean;
-}
-export interface INeedleTextureTransformContext {
-    prepare(document: Document): Promise<void | boolean>;
-    process(index: number, texture: Texture, settings: NEEDLE_compression_texture_schema, context: NeedleTransformContext): Promise<boolean>;
-    finalize(document: Document): Promise<void>;
-}
+import { Document, Texture } from '@gltf-transform/core';
+import { NEEDLE_compression_texture_schema } from '../extensions/index.js';
+import { Config } from '../config/index.js';
+export interface NeedleTransformContext {
+    /** full path to the file being processed */
+    file: string;
+    config: Config;
+    debug?: boolean;
+    useCache: boolean;
+    noToktx: boolean;
+}
+export interface INeedleTextureTransformContext {
+    prepare(document: Document): Promise<void | boolean>;
+    process(index: number, texture: Texture, settings: NEEDLE_compression_texture_schema, context: NeedleTransformContext): Promise<boolean>;
+    finalize(document: Document): Promise<void>;
+}

package/dist/transforms/needle_common.js

@@ -1 +1 @@
-export {};
+export {};

package/dist/transforms/needle_mesh_transform.d.ts

@@ -1,10 +1,10 @@
-import { Transform, Document, Primitive, Mesh } from "@gltf-transform/core";
-import { SimplifyOptions, WeldOptions } from "@gltf-transform/functions";
-import { Config } from "../config/index.js";
-declare type MeshTransformContext = {
-    file: string;
-    config: Config;
-};
-export declare const needle_mesh_transform: (context: MeshTransformContext, simplify: Omit<SimplifyOptions, "simplifier">) => Transform;
-export declare function compressPrimitive(document: Document, mesh: Mesh, prim: Primitive, index: number, weldOptions: Required<WeldOptions>, meshOptions: Required<SimplifyOptions>): Promise<Primitive>;
-export {};
+import { Transform, Document, Primitive, Mesh } from "@gltf-transform/core";
+import { SimplifyOptions, WeldOptions } from "@gltf-transform/functions";
+import { Config } from "../config/index.js";
+declare type MeshTransformContext = {
+    file: string;
+    config: Config;
+};
+export declare const needle_mesh_transform: (context: MeshTransformContext, simplify: Omit<SimplifyOptions, "simplifier">) => Transform;
+export declare function compressPrimitive(document: Document, mesh: Mesh, prim: Primitive, index: number, weldOptions: Required<WeldOptions>, meshOptions: Required<SimplifyOptions>): Promise<Primitive>;
+export {};