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

package/dist/utils/stats.js

@@ -1,166 +1,191 @@
-import { getVersion } from "./version.js";
-import { Document, ImageUtils } from "@gltf-transform/core";
-import { getFileName } from "./fileutils.js";
-import { statSync, writeFileSync } from "fs";
-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;
-    nodes;
-    materials;
-    meshes;
-    textures;
-    constructor(document, size) {
-        const root = document.getRoot();
-        const asset = root.getAsset();
-        this.asset = {
-            generator: asset.generator,
-            version: asset.version,
-            copyright: asset.copyright,
-            extras: asset.extras,
-        };
-        this.size = size;
-        this.nodes = root.listNodes().length;
-        this.materials = root.listMaterials().length;
-        this.meshes = calculateMeshInfo(document);
-        this.textures = calculateTextureInfo(document);
-    }
-    static combine(others) {
-        const res = new Stats(new Document(), 0);
-        for (const other of others) {
-            res.size += other.size;
-            res.nodes += other.nodes;
-            res.materials += other.materials;
-            res.meshes.addTo(other.meshes);
-            res.textures.addTo(other.textures);
-        }
-        return res;
-    }
-}
-export class FileStats extends Stats {
-    filename;
-    constructor(file, document) {
-        super(document, statSync(file).size);
-        this.filename = getFileName(file);
-    }
-}
-export class MeshInfo {
-    count = 0;
-    primitives = 0;
-    vertices = 0;
-    triangles = 0;
-    memory = 0;
-    formats = [];
-    addTo(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)));
-    }
-}
-export class TextureInfo {
-    count = 0;
-    memory = 0;
-    gpu_memory = 0;
-    formats = [];
-    addTo(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)));
-    }
-}
-/**
- * Create a new filestats object from a file and a document
- */
-export function createNewFilestats(file, document) {
-    const filestats = new FileStats(file, document);
-    return filestats;
-}
-export function writeFileStatsToFile(filestats, output_path) {
-    if (output_path == undefined) {
-        console.error("No stats output path provided");
-        return null;
-    }
-    const res = {
-        summary: Stats.combine(filestats),
-        files: filestats,
-    };
-    const json = JSON.stringify(res);
-    writeFileSync(output_path, json);
-    return json;
-}
-function calculateMeshInfo(document) {
-    const root = document.getRoot();
-    const meshes = root.listMeshes();
-    const res = new MeshInfo();
-    res.count = meshes.length;
-    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) {
-    const root = document.getRoot();
-    const textures = root.listTextures();
-    const res = new TextureInfo();
-    res.count = textures.length;
-    res.formats = textures.map(t => t.getMimeType());
-    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;
-}
+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";
+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;
+    nodes;
+    materials;
+    meshes;
+    textures;
+    constructor(document, size) {
+        const root = document.getRoot();
+        const asset = root.getAsset();
+        this.asset = {
+            generator: asset.generator,
+            version: asset.version,
+            copyright: asset.copyright,
+            extras: asset.extras,
+        };
+        this.size = size;
+        this.nodes = root.listNodes().length;
+        this.materials = root.listMaterials().length;
+        this.meshes = calculateMeshInfo(document);
+        this.textures = calculateTextureInfo(document);
+    }
+    static combine(others, type) {
+        const res = new Stats(new Document(), 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.nodes += other.nodes;
+            res.materials += other.materials;
+            res.meshes.addTo(other.meshes);
+            res.textures.addTo(other.textures);
+        }
+        if (!foundAny) {
+            return null;
+        }
+        return res;
+    }
+}
+export class FileStats extends Stats {
+    filename;
+    isLOD;
+    constructor(file, document) {
+        super(document, 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 = [];
+    addTo(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)));
+    }
+}
+export class TextureInfo {
+    count = 0;
+    memory = 0;
+    gpu_memory = 0;
+    formats = [];
+    addTo(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)));
+    }
+}
+/**
+ * Create a new filestats object from a file and a document
+ */
+export function createNewFilestats(file, document) {
+    const filestats = new FileStats(file, document);
+    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) {
+    const root = document.getRoot();
+    const meshes = root.listMeshes();
+    const res = new MeshInfo();
+    res.count = meshes.length;
+    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) {
+    const root = document.getRoot();
+    const textures = root.listTextures();
+    const res = new TextureInfo();
+    res.count = textures.length;
+    res.formats = textures.map(t => t.getMimeType());
+    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;
+}

package/dist/utils/texture.d.ts

@@ -1,2 +1,2 @@
-export declare function isMultipleOfFour(value: number): boolean;
-export declare function ceilMultipleOfFour(value: number): number;
+export declare function isMultipleOfFour(value: number): boolean;
+export declare function ceilMultipleOfFour(value: number): number;

package/dist/utils/texture.js

@@ -1,8 +1,8 @@
-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 isMultipleOfFour(value) {
+    return value % 4 === 0;
+}
+export function ceilMultipleOfFour(value) {
+    if (value <= 4)
+        return 4;
+    return value % 4 ? value + 4 - (value % 4) : value;
+}

package/dist/utils/validate.d.ts

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

package/dist/utils/validate.js

@@ -0,0 +1,16 @@
+import { ImageUtils } from "@gltf-transform/core";
+export function validateImageMimeType(mimetype, image) {
+    const actualMimeType = ImageUtils.getMimeType(image);
+    if (actualMimeType != null && actualMimeType != mimetype) {
+        console.error(`Expected image to be of type ${mimetype}, but was ${actualMimeType}`);
+        return {
+            error: true,
+            message: `Expected image to be of type ${mimetype}, but was ${actualMimeType}`,
+            mimeType: actualMimeType
+        };
+    }
+    else if (actualMimeType === null) {
+        console.warn("Could not determine image type");
+    }
+    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.js

@@ -1,5 +1,5 @@
-import packageJson from "#package.json" assert { type: "json" };
-export function getVersion(_marklocal = true) {
-    let res = packageJson.version;
-    return res;
-}
+import packageJson from "#package.json" assert { type: "json" };
+export function getVersion(_marklocal = true) {
+    let res = packageJson.version;
+    return res;
+}

package/package.json

@@ -1,76 +1,77 @@
-{
-  "name": "@needle-tools/gltf-build-pipeline",
-  "version": "2.2.1-alpha.2",
-  "description": "Pipeline and tools for optimizing gltf files using gltf-transform and compression settings within glTF extensions",
-  "main": "dist/index.js",
-  "type": "module",
-  "readme": "README.md",
-  "author": {
-    "name": "Needle",
-    "email": "help@needle.tools",
-    "url": "https://needle.tools/"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/needle-tools/needle-gltf-extensions.git"
-  },
-  "bin": {
-    "gltf-build-pipeline": "dist/cli/index.js",
-    "needle-gltf": "dist/cli/index.js"
-  },
-  "imports": {
-    "#package.json": "./package.json"
-  },
-  "scripts": {
-    "start": "node scripts/index.mjs",
-    "dev": "npm-watch compile",
-    "compile": "node tools/prebuild.mjs && (tsc || exit 1) && node tools/postbuild.mjs",
-    "clear-caches": "node scripts/clear-caches.mjs",
-    "limit-caches": "node scripts/limit-caches.mjs",
-    "transform": "node scripts/index.mjs",
-    "transform:make-progressive": "node scripts/make-progressive.mjs",
-    "transform:pack-gltf": "node --no-experimental-fetch scripts/pack-gltf.mjs",
-    "pack-gltf": "node --no-experimental-fetch scripts/pack-gltf.mjs",
-    "dev:pack-gltf": "npm run compile && node scripts/pack-gltf.mjs"
-  },
-  "devDependencies": {
-    "@types/node": "^18.7.23",
-    "npm-watch": "^0.13.0",
-    "typescript": "^4.9.5"
-  },
-  "optionalDependencies": {
-    "@img/sharp-darwin-arm64": "^0.33.4",
-    "@img/sharp-darwin-x64": "^0.33.4",
-    "@img/sharp-linux-arm": "^0.33.4",
-    "@img/sharp-win32-x64": "^0.33.4"
-  },
-  "dependencies": {
-    "@donmccurdy/caporal": "~0.0.10",
-    "@gltf-transform/core": "^4.0.1",
-    "@gltf-transform/extensions": "^4.0.1",
-    "@gltf-transform/functions": "^4.0.1",
-    "command-exists": "^1.2.9",
-    "command-line-args": "^5.2.1",
-    "draco3dgltf": "^1.5.3",
-    "glob": "^7.2.0",
-    "meshoptimizer": "^0.18.1",
-    "micromatch": "^4.0.5",
-    "ndarray": "^1.0.19",
-    "ndarray-lanczos": "^0.3.0",
-    "ndarray-pixels": "^2.0.1",
-    "p-limit": "3.1.0",
-    "semver": "^7.3.7",
-    "sharp": "^0.33.4",
-    "tmp": "^0.2.1",
-    "uuid": "^9.0.1"
-  },
-  "watch": {
-    "compile": {
-      "patterns": [
-        "src"
-      ],
-      "extensions": "ts",
-      "quiet": false
-    }
-  }
-}
+{
+  "name": "@needle-tools/gltf-build-pipeline",
+  "version": "2.2.1-alpha.3",
+  "description": "Pipeline and tools for optimizing gltf files using gltf-transform and compression settings within glTF extensions",
+  "main": "dist/index.js",
+  "type": "module",
+  "readme": "README.md",
+  "author": {
+    "name": "Needle",
+    "email": "help@needle.tools",
+    "url": "https://needle.tools/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/needle-tools/needle-gltf-extensions.git"
+  },
+  "bin": {
+    "gltf-build-pipeline": "dist/cli/index.js",
+    "needle-gltf": "dist/cli/index.js"
+  },
+  "imports": {
+    "#package.json": "./package.json"
+  },
+  "scripts": {
+    "start": "node scripts/index.mjs",
+    "dev": "npm-watch compile",
+    "publish": "npm run compile && npm publish --access public",
+    "compile": "node tools/prebuild.mjs && (tsc || exit 1) && node tools/postbuild.mjs",
+    "clear-caches": "node scripts/clear-caches.mjs",
+    "limit-caches": "node scripts/limit-caches.mjs",
+    "transform": "node scripts/index.mjs",
+    "transform:make-progressive": "node scripts/make-progressive.mjs",
+    "transform:pack-gltf": "node --no-experimental-fetch scripts/pack-gltf.mjs",
+    "pack-gltf": "node --no-experimental-fetch scripts/pack-gltf.mjs",
+    "dev:pack-gltf": "npm run compile && node scripts/pack-gltf.mjs"
+  },
+  "devDependencies": {
+    "@types/node": "^18.7.23",
+    "npm-watch": "^0.13.0",
+    "typescript": "^4.9.5"
+  },
+  "optionalDependencies": {
+    "@img/sharp-darwin-arm64": "^0.33.4",
+    "@img/sharp-darwin-x64": "^0.33.4",
+    "@img/sharp-linux-arm": "^0.33.4",
+    "@img/sharp-win32-x64": "^0.33.4"
+  },
+  "dependencies": {
+    "@donmccurdy/caporal": "~0.0.10",
+    "@gltf-transform/core": "^4.0.1",
+    "@gltf-transform/extensions": "^4.0.1",
+    "@gltf-transform/functions": "^4.0.1",
+    "command-exists": "^1.2.9",
+    "command-line-args": "^5.2.1",
+    "draco3dgltf": "^1.5.3",
+    "glob": "^7.2.0",
+    "meshoptimizer": "^0.18.1",
+    "micromatch": "^4.0.5",
+    "ndarray": "^1.0.19",
+    "ndarray-lanczos": "^0.3.0",
+    "ndarray-pixels": "^2.0.1",
+    "p-limit": "3.1.0",
+    "semver": "^7.3.7",
+    "sharp": "^0.33.4",
+    "tmp": "^0.2.1",
+    "uuid": "^9.0.1"
+  },
+  "watch": {
+    "compile": {
+      "patterns": [
+        "src"
+      ],
+      "extensions": "ts",
+      "quiet": false
+    }
+  }
+}

package/scripts/clear-caches.mjs

@@ -1,4 +1,4 @@
-
-import { clearCache } from '../dist/cache/index.js';
-
+
+import { clearCache } from '../dist/cache/index.js';
+
 clearCache();

package/scripts/defaults.mjs

@@ -1,12 +1,12 @@
-import { ALL_EXTENSIONS } from '@gltf-transform/extensions';
-import { ALL_EXTENSIONS as NEEDLE_EXTENSIONS } from "../dist/extensions/NEEDLE_opaque/index.js";
-import { NEEDLE_progressive } from '../dist/index.js';
-
-
-export function registerExtensions(node) {
-    node.registerExtensions(ALL_EXTENSIONS);
-    node.registerExtensions(NEEDLE_EXTENSIONS);
-    node.registerExtensions([
-        NEEDLE_progressive
-    ])
+import { ALL_EXTENSIONS } from '@gltf-transform/extensions';
+import { ALL_EXTENSIONS as NEEDLE_EXTENSIONS } from "../dist/extensions/NEEDLE_opaque/index.js";
+import { NEEDLE_progressive } from '../dist/index.js';
+
+
+export function registerExtensions(node) {
+    node.registerExtensions(ALL_EXTENSIONS);
+    node.registerExtensions(NEEDLE_EXTENSIONS);
+    node.registerExtensions([
+        NEEDLE_progressive
+    ])
 }

package/scripts/fileutils.mjs

@@ -1,6 +1,6 @@
-import { foreachGLTF as foreach } from '../dist/index.js';
-
-
-export function foreachGLTF(args, callback) {
-    return foreach(args, callback);
+import { foreachGLTF as foreach } from '../dist/index.js';
+
+
+export function foreachGLTF(args, callback) {
+    return foreach(args, callback);
 }