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

package/dist/utils/stats.js

@@ -1,258 +1,258 @@
-import { getVersion } from "./version.js";
-import { Document, ImageUtils } from "@gltf-transform/core";
-import { getFileName } from "./fileutils.js";
-import { statSync, writeFileSync } from "fs";
-import { isLOD } from "../transforms/needle_progressive.js";
-import { inspect } from "@gltf-transform/functions";
-export function printStats(stats, logger, config) {
-    const duration = Date.now() - stats.startTime;
-    const durationInMinutes = duration / 1000 / 60;
-    const msg = `[Needle Build Pipeline] v${getVersion()} — Finished compression \"${config?.usecase}\" of ${stats.totalFilesProcessed} files in ${durationInMinutes.toFixed(1)} minutes; total size ${stats.totalFileSizeInMBBefore.toFixed(1)} MB → ${stats.totalFileSizeInMB.toFixed(1)} MB, total GPU memory: ${stats.totalGPUMemoryInMB.toFixed(1)} MB`;
-    if (logger)
-        logger.info(msg);
-    else
-        console.log(msg);
-}
-class Stats {
-    /** Size in bytes */
-    size;
-    asset;
-    json;
-    nodes;
-    materials;
-    meshes;
-    textures;
-    animations;
-    constructor(document, json, size) {
-        const root = document.getRoot();
-        const asset = root.getAsset();
-        this.asset = {
-            generator: asset.generator,
-            version: asset.version,
-            copyright: asset.copyright,
-            extras: asset.extras,
-        };
-        const report = inspect(document);
-        this.size = size;
-        this.json = calculateJSONDocumentInfo(json);
-        this.nodes = root.listNodes().length;
-        this.materials = root.listMaterials().length;
-        this.meshes = calculateMeshInfo(document, report);
-        this.textures = calculateTextureInfo(document, report);
-        this.animations = calculateAnimationInfo(document);
-    }
-    static combine(others, type) {
-        const res = new Stats(new Document(), null, 0);
-        let foundAny = false;
-        for (const other of others) {
-            if (type != undefined) {
-                const filename = other.filename;
-                if (filename) {
-                    // skip main files if we only want LODs
-                    if (isLOD(filename)) {
-                        if (type === "main")
-                            continue;
-                    }
-                    // skip LODs if we only want main files
-                    else {
-                        if (type === "lods")
-                            continue;
-                    }
-                }
-            }
-            foundAny = true;
-            res.size += other.size;
-            res.json.addFrom(other.json);
-            res.nodes += other.nodes;
-            res.materials += other.materials;
-            res.meshes.addFrom(other.meshes);
-            res.textures.addFrom(other.textures);
-            res.animations.addFrom(other.animations);
-        }
-        if (!foundAny) {
-            return null;
-        }
-        return res;
-    }
-}
-export class FileStats extends Stats {
-    filename;
-    isLOD;
-    constructor(file, document, json) {
-        super(document, json, statSync(file).size);
-        this.filename = getFileName(file);
-        this.isLOD = isLOD(this.filename);
-    }
-}
-export class MeshInfo {
-    count = 0;
-    primitives = 0;
-    vertices = 0;
-    triangles = 0;
-    memory = 0;
-    formats = [];
-    errors;
-    warnings;
-    addFrom(other) {
-        this.count += other.count;
-        this.primitives += other.primitives;
-        this.vertices += other.vertices;
-        this.triangles += other.triangles;
-        this.memory += other.memory;
-        this.formats = Array.from(new Set(this.formats.concat(other.formats)));
-        this.errors = Array.from(new Set(this.errors?.concat(other.errors)));
-        this.warnings = Array.from(new Set(this.warnings?.concat(other.warnings)));
-    }
-}
-export class TextureInfo {
-    count = 0;
-    memory = 0;
-    gpu_memory = 0;
-    formats = [];
-    errors;
-    warnings;
-    addFrom(other) {
-        this.count += other.count;
-        this.memory += other.memory;
-        this.gpu_memory += other.gpu_memory;
-        this.formats = Array.from(new Set(this.formats.concat(other.formats)));
-        this.errors = Array.from(new Set(this.errors?.concat(other.errors)));
-        this.warnings = Array.from(new Set(this.warnings?.concat(other.warnings)));
-    }
-}
-export class AnimationInfo {
-    count = 0;
-    size = 0;
-    channels = 0;
-    addFrom(other) {
-        this.count += other.count;
-        this.size += other.size;
-        this.channels += other.channels;
-    }
-}
-export class JSONDocumentInfo {
-    size = 0;
-    addFrom(other) {
-        this.size += other.size;
-    }
-}
-/**
- * Create a new filestats object from a file and a document
- */
-export function createNewFilestats(file, document, jsonDocument) {
-    const filestats = new FileStats(file, document, jsonDocument);
-    return filestats;
-}
-export function writeFileStatsToFile(filestats, output_path) {
-    if (output_path == undefined) {
-        console.error("No stats output path provided");
-        return null;
-    }
-    const res = {
-        sum: Stats.combine(filestats),
-        // main: Stats.combine(filestats, "main"),
-        // lods: Stats.combine(filestats, "lods"),
-        files: filestats,
-    };
-    const json = JSON.stringify(res);
-    writeFileSync(output_path, json);
-    return json;
-}
-function calculateMeshInfo(document, report) {
-    const root = document.getRoot();
-    const meshes = root.listMeshes();
-    const res = new MeshInfo();
-    res.count = meshes.length;
-    res.errors = report.meshes.errors;
-    res.warnings = report.meshes.warnings;
-    for (const mesh of root.listMeshes()) {
-        const primitives = mesh.listPrimitives();
-        res.primitives += primitives.length;
-        for (const prim of primitives) {
-            const positions = prim.getAttribute('POSITION');
-            const indices = prim.getIndices();
-            if (positions) {
-                res.vertices += positions.getCount();
-            }
-            if (indices) {
-                res.triangles += indices.getCount() / 3;
-            }
-            else {
-                res.triangles += positions.getCount() / 3;
-            }
-            const semantics = prim.listSemantics();
-            for (const semantic of semantics) {
-                const accessor = prim.getAttribute(semantic);
-                if (accessor) {
-                    const buffer = accessor.getByteLength();
-                    res.memory += buffer;
-                }
-            }
-        }
-    }
-    const extensions = root.listExtensionsUsed();
-    for (const ext of extensions) {
-        if (ext.extensionName.startsWith("EXT_meshopt_compression")) {
-            res.formats.push("meshopt");
-        }
-        else if (ext.extensionName.startsWith("KHR_draco_mesh_compression")) {
-            res.formats.push("draco");
-        }
-    }
-    // filter formats so we only have unique values
-    res.formats = Array.from(new Set(res.formats));
-    return res;
-}
-function calculateTextureInfo(document, report) {
-    const root = document.getRoot();
-    const textures = root.listTextures();
-    const res = new TextureInfo();
-    res.count = textures.length;
-    res.formats = textures.map(t => t.getMimeType());
-    res.errors = report.textures.errors;
-    res.warnings = report.textures.warnings;
-    res.gpu_memory = 0;
-    res.memory = 0;
-    for (const texture of textures) {
-        const image = texture.getImage();
-        const mimetype = texture.getMimeType();
-        if (image && mimetype) {
-            res.gpu_memory += ImageUtils.getVRAMByteLength(image, mimetype);
-            res.memory += image.byteLength;
-        }
-    }
-    // filter formats so we only have unique values
-    res.formats = Array.from(new Set(res.formats));
-    return res;
-}
-function calculateAnimationInfo(document) {
-    const animations = document.getRoot().listAnimations();
-    const info = new AnimationInfo();
-    info.count = animations.length;
-    info.channels = 0;
-    info.size = 0;
-    for (const anim of animations) {
-        // calculate animation size
-        const channels = anim.listChannels();
-        info.channels += channels.length;
-        for (const channel of channels) {
-            const sampler = channel.getSampler();
-            const times = sampler.getInput();
-            const values = sampler.getOutput();
-            if (times) {
-                info.size += times.getArray()?.byteLength ?? 0;
-            }
-            if (values) {
-                info.size += values.getArray()?.byteLength ?? 0;
-            }
-        }
-    }
-    return info;
-}
-function calculateJSONDocumentInfo(json) {
-    const info = new JSONDocumentInfo();
-    if (json) {
-        info.size = JSON.stringify(json.json).length;
-    }
-    return info;
-}
+import { getVersion } from "./version.js";
+import { Document, ImageUtils } from "@gltf-transform/core";
+import { getFileName } from "./fileutils.js";
+import { statSync, writeFileSync } from "fs";
+import { isLOD } from "../transforms/needle_progressive.js";
+import { inspect } from "@gltf-transform/functions";
+export function printStats(stats, logger, config) {
+    const duration = Date.now() - stats.startTime;
+    const durationInMinutes = duration / 1000 / 60;
+    const msg = `[Needle Build Pipeline] v${getVersion()} — Finished compression \"${config?.usecase}\" of ${stats.totalFilesProcessed} files in ${durationInMinutes.toFixed(1)} minutes; total size ${stats.totalFileSizeInMBBefore.toFixed(1)} MB → ${stats.totalFileSizeInMB.toFixed(1)} MB, total GPU memory: ${stats.totalGPUMemoryInMB.toFixed(1)} MB`;
+    if (logger)
+        logger.info(msg);
+    else
+        console.log(msg);
+}
+class Stats {
+    /** Size in bytes */
+    size;
+    asset;
+    json;
+    nodes;
+    materials;
+    meshes;
+    textures;
+    animations;
+    constructor(document, json, size) {
+        const root = document.getRoot();
+        const asset = root.getAsset();
+        this.asset = {
+            generator: asset.generator,
+            version: asset.version,
+            copyright: asset.copyright,
+            extras: asset.extras,
+        };
+        const report = inspect(document);
+        this.size = size;
+        this.json = calculateJSONDocumentInfo(json);
+        this.nodes = root.listNodes().length;
+        this.materials = root.listMaterials().length;
+        this.meshes = calculateMeshInfo(document, report);
+        this.textures = calculateTextureInfo(document, report);
+        this.animations = calculateAnimationInfo(document);
+    }
+    static combine(others, type) {
+        const res = new Stats(new Document(), null, 0);
+        let foundAny = false;
+        for (const other of others) {
+            if (type != undefined) {
+                const filename = other.filename;
+                if (filename) {
+                    // skip main files if we only want LODs
+                    if (isLOD(filename)) {
+                        if (type === "main")
+                            continue;
+                    }
+                    // skip LODs if we only want main files
+                    else {
+                        if (type === "lods")
+                            continue;
+                    }
+                }
+            }
+            foundAny = true;
+            res.size += other.size;
+            res.json.addFrom(other.json);
+            res.nodes += other.nodes;
+            res.materials += other.materials;
+            res.meshes.addFrom(other.meshes);
+            res.textures.addFrom(other.textures);
+            res.animations.addFrom(other.animations);
+        }
+        if (!foundAny) {
+            return null;
+        }
+        return res;
+    }
+}
+export class FileStats extends Stats {
+    filename;
+    isLOD;
+    constructor(file, document, json) {
+        super(document, json, statSync(file).size);
+        this.filename = getFileName(file);
+        this.isLOD = isLOD(this.filename);
+    }
+}
+export class MeshInfo {
+    count = 0;
+    primitives = 0;
+    vertices = 0;
+    triangles = 0;
+    memory = 0;
+    formats = [];
+    errors;
+    warnings;
+    addFrom(other) {
+        this.count += other.count;
+        this.primitives += other.primitives;
+        this.vertices += other.vertices;
+        this.triangles += other.triangles;
+        this.memory += other.memory;
+        this.formats = Array.from(new Set(this.formats.concat(other.formats)));
+        this.errors = Array.from(new Set(this.errors?.concat(other.errors)));
+        this.warnings = Array.from(new Set(this.warnings?.concat(other.warnings)));
+    }
+}
+export class TextureInfo {
+    count = 0;
+    memory = 0;
+    gpu_memory = 0;
+    formats = [];
+    errors;
+    warnings;
+    addFrom(other) {
+        this.count += other.count;
+        this.memory += other.memory;
+        this.gpu_memory += other.gpu_memory;
+        this.formats = Array.from(new Set(this.formats.concat(other.formats)));
+        this.errors = Array.from(new Set(this.errors?.concat(other.errors)));
+        this.warnings = Array.from(new Set(this.warnings?.concat(other.warnings)));
+    }
+}
+export class AnimationInfo {
+    count = 0;
+    size = 0;
+    channels = 0;
+    addFrom(other) {
+        this.count += other.count;
+        this.size += other.size;
+        this.channels += other.channels;
+    }
+}
+export class JSONDocumentInfo {
+    size = 0;
+    addFrom(other) {
+        this.size += other.size;
+    }
+}
+/**
+ * Create a new filestats object from a file and a document
+ */
+export function createNewFilestats(file, document, jsonDocument) {
+    const filestats = new FileStats(file, document, jsonDocument);
+    return filestats;
+}
+export function writeFileStatsToFile(filestats, output_path) {
+    if (output_path == undefined) {
+        console.error("No stats output path provided");
+        return null;
+    }
+    const res = {
+        sum: Stats.combine(filestats),
+        // main: Stats.combine(filestats, "main"),
+        // lods: Stats.combine(filestats, "lods"),
+        files: filestats,
+    };
+    const json = JSON.stringify(res);
+    writeFileSync(output_path, json);
+    return json;
+}
+function calculateMeshInfo(document, report) {
+    const root = document.getRoot();
+    const meshes = root.listMeshes();
+    const res = new MeshInfo();
+    res.count = meshes.length;
+    res.errors = report.meshes.errors;
+    res.warnings = report.meshes.warnings;
+    for (const mesh of root.listMeshes()) {
+        const primitives = mesh.listPrimitives();
+        res.primitives += primitives.length;
+        for (const prim of primitives) {
+            const positions = prim.getAttribute('POSITION');
+            const indices = prim.getIndices();
+            if (positions) {
+                res.vertices += positions.getCount();
+            }
+            if (indices) {
+                res.triangles += indices.getCount() / 3;
+            }
+            else {
+                res.triangles += positions.getCount() / 3;
+            }
+            const semantics = prim.listSemantics();
+            for (const semantic of semantics) {
+                const accessor = prim.getAttribute(semantic);
+                if (accessor) {
+                    const buffer = accessor.getByteLength();
+                    res.memory += buffer;
+                }
+            }
+        }
+    }
+    const extensions = root.listExtensionsUsed();
+    for (const ext of extensions) {
+        if (ext.extensionName.startsWith("EXT_meshopt_compression")) {
+            res.formats.push("meshopt");
+        }
+        else if (ext.extensionName.startsWith("KHR_draco_mesh_compression")) {
+            res.formats.push("draco");
+        }
+    }
+    // filter formats so we only have unique values
+    res.formats = Array.from(new Set(res.formats));
+    return res;
+}
+function calculateTextureInfo(document, report) {
+    const root = document.getRoot();
+    const textures = root.listTextures();
+    const res = new TextureInfo();
+    res.count = textures.length;
+    res.formats = textures.map(t => t.getMimeType());
+    res.errors = report.textures.errors;
+    res.warnings = report.textures.warnings;
+    res.gpu_memory = 0;
+    res.memory = 0;
+    for (const texture of textures) {
+        const image = texture.getImage();
+        const mimetype = texture.getMimeType();
+        if (image && mimetype) {
+            res.gpu_memory += ImageUtils.getVRAMByteLength(image, mimetype);
+            res.memory += image.byteLength;
+        }
+    }
+    // filter formats so we only have unique values
+    res.formats = Array.from(new Set(res.formats));
+    return res;
+}
+function calculateAnimationInfo(document) {
+    const animations = document.getRoot().listAnimations();
+    const info = new AnimationInfo();
+    info.count = animations.length;
+    info.channels = 0;
+    info.size = 0;
+    for (const anim of animations) {
+        // calculate animation size
+        const channels = anim.listChannels();
+        info.channels += channels.length;
+        for (const channel of channels) {
+            const sampler = channel.getSampler();
+            const times = sampler.getInput();
+            const values = sampler.getOutput();
+            if (times) {
+                info.size += times.getArray()?.byteLength ?? 0;
+            }
+            if (values) {
+                info.size += values.getArray()?.byteLength ?? 0;
+            }
+        }
+    }
+    return info;
+}
+function calculateJSONDocumentInfo(json) {
+    const info = new JSONDocumentInfo();
+    if (json) {
+        info.size = JSON.stringify(json.json).length;
+    }
+    return info;
+}

package/dist/utils/texture.d.ts

@@ -1,5 +1,5 @@
-import { Texture } from "@gltf-transform/core";
-export declare function isMultipleOfFour(value: number): boolean;
-export declare function ceilMultipleOfFour(value: number): number;
-export declare function isLightmap(texture: Texture): boolean;
-export declare function setLightmapName(texture: Texture): void;
+import { Texture } from "@gltf-transform/core";
+export declare function isMultipleOfFour(value: number): boolean;
+export declare function ceilMultipleOfFour(value: number): number;
+export declare function isLightmap(texture: Texture): boolean;
+export declare function setLightmapName(texture: Texture): void;

package/dist/utils/texture.js

@@ -1,14 +1,14 @@
-export function isMultipleOfFour(value) {
-    return value % 4 === 0;
-}
-export function ceilMultipleOfFour(value) {
-    if (value <= 4)
-        return 4;
-    return value % 4 ? value + 4 - (value % 4) : value;
-}
-export function isLightmap(texture) {
-    return texture.getName()?.startsWith("Lightmap");
-}
-export function setLightmapName(texture) {
-    texture.setName("Lightmap");
-}
+export function isMultipleOfFour(value) {
+    return value % 4 === 0;
+}
+export function ceilMultipleOfFour(value) {
+    if (value <= 4)
+        return 4;
+    return value % 4 ? value + 4 - (value % 4) : value;
+}
+export function isLightmap(texture) {
+    return texture.getName()?.startsWith("Lightmap");
+}
+export function setLightmapName(texture) {
+    texture.setName("Lightmap");
+}

package/dist/utils/validate.d.ts

@@ -1,5 +1,5 @@
-export declare function validateImageMimeType(mimetype: string, image: Uint8Array): {
-    error: boolean;
-    message: string;
-    mimeType: string;
-};
+export declare function validateImageMimeType(mimetype: string, image: Uint8Array): {
+    error: boolean;
+    message: string;
+    mimeType: string;
+};

package/dist/utils/validate.js

@@ -1,17 +1,17 @@
-import { ImageUtils } from "@gltf-transform/core";
-export function validateImageMimeType(mimetype, image) {
-    const actualMimeType = ImageUtils.getMimeType(image);
-    if (actualMimeType != null && actualMimeType != mimetype) {
-        const msg = `Image reported wrong mime type \"${mimetype}\" but is actually \"${actualMimeType}\"`;
-        console.error(`WARN: ${msg}`);
-        return {
-            error: true,
-            message: msg,
-            mimeType: actualMimeType
-        };
-    }
-    else if (actualMimeType === null) {
-        console.warn(`WARN: Could not validate image type for \"${mimetype}\"`);
-    }
-    return null;
-}
+import { ImageUtils } from "@gltf-transform/core";
+export function validateImageMimeType(mimetype, image) {
+    const actualMimeType = ImageUtils.getMimeType(image);
+    if (actualMimeType != null && actualMimeType != mimetype) {
+        const msg = `Image reported wrong mime type \"${mimetype}\" but is actually \"${actualMimeType}\"`;
+        console.error(`WARN: ${msg}`);
+        return {
+            error: true,
+            message: msg,
+            mimeType: actualMimeType
+        };
+    }
+    else if (actualMimeType === null) {
+        console.warn(`WARN: Could not validate image type for \"${mimetype}\"`);
+    }
+    return null;
+}

package/dist/utils/version.d.ts

@@ -1 +1 @@
-export declare function getVersion(_marklocal?: boolean): string;
+export declare function getVersion(_marklocal?: boolean): string;

package/dist/utils/version.gen.d.ts

@@ -1 +1 @@
-export declare const version = "2.13.0";
+export declare const version = "2.13.1";

package/dist/utils/version.gen.js

@@ -1 +1 @@
-export const version = "2.13.0";
+export const version = "2.13.1";

package/dist/utils/version.js

@@ -1,4 +1,4 @@
-import { version } from './version.gen.js';
-export function getVersion(_marklocal = true) {
-    return version;
-}
+import { version } from './version.gen.js';
+export function getVersion(_marklocal = true) {
+    return version;
+}