@needle-tools/gltf-build-pipeline 1.0.5 → 1.1.0

package/CHANGELOG.md

@@ -4,6 +4,12 @@ All notable changes to this package will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
+## [1.1.0] - 2023-05-06
+- add: support for per glb mesh compression selection (none, draco or meshopt)
+
+## [1.0.6] - 2023-05-06
+- fix: dont add textures to cache when toktx is not installed
+
 ## [1.0.5] - 2023-05-06
 - fix: catch exception in cases where toktx is not installed (e.g. in CI environment) and log warning instead
 

package/dist/extensions/NEEDLE_mesh_compression/NEEDLE_mesh_compression.d.ts

@@ -1,5 +1,8 @@
 import { Extension, ExtensionProperty, PropertyType, ReaderContext } from "@gltf-transform/core";
-declare interface NEEDLE_mesh_compression_model {
+export declare class NEEDLE_mesh_compression_model_root {
+    compression: "none" | "draco" | "meshopt";
+}
+export declare class NEEDLE_mesh_compression_model {
     useSimplifier: boolean;
     error: number;
     ratio: number;
@@ -8,7 +11,7 @@ declare interface NEEDLE_mesh_compression_model {
 export declare class NEEDLE_mesh_compression extends Extension {
     static EXTENSION_NAME: string;
     extensionName: string;
-    create(model: NEEDLE_mesh_compression_model): NEEDLE_mesh_compression_property;
+    create(model: NEEDLE_mesh_compression_model | NEEDLE_mesh_compression_model_root): NEEDLE_mesh_compression_property;
     read(context: ReaderContext): this;
     write(ctx: any): this;
 }
@@ -18,6 +21,5 @@ export declare class NEEDLE_mesh_compression_property extends ExtensionProperty
     parentTypes: PropertyType[];
     propertyType: string;
     init(): void;
-    model: NEEDLE_mesh_compression_model;
+    model: NEEDLE_mesh_compression_model | NEEDLE_mesh_compression_model_root;
 }
-export {};

package/dist/extensions/NEEDLE_mesh_compression/NEEDLE_mesh_compression.js

@@ -1,5 +1,15 @@
 import { Extension, ExtensionProperty, PropertyType } from "@gltf-transform/core";
 const EXTENSION_NAME = "NEEDLE_mesh_compression";
+// TODO: this extension can now be on the root and on primitives containing different contents
+export class NEEDLE_mesh_compression_model_root {
+    compression;
+}
+export class NEEDLE_mesh_compression_model {
+    useSimplifier;
+    error;
+    ratio;
+    lockBorder;
+}
 const debugLog = false;
 export class NEEDLE_mesh_compression extends Extension {
     static EXTENSION_NAME = EXTENSION_NAME;
@@ -10,23 +20,27 @@ export class NEEDLE_mesh_compression extends Extension {
         return ext;
     }
     read(context) {
-        if (!context.jsonDoc.json.meshes)
-            return;
         if (debugLog)
             console.log("READ " + EXTENSION_NAME);
-        context.meshes?.forEach((mesh, index) => {
-            const meshDefinition = context.jsonDoc.json.meshes[index];
-            if (!meshDefinition)
-                return;
-            const primitives = mesh.listPrimitives();
-            for (let i = 0; i < primitives.length; i++) {
-                const primitive = meshDefinition.primitives[i];
-                if (primitive.extensions && primitive.extensions[EXTENSION_NAME]) {
-                    const model = primitive.extensions[EXTENSION_NAME];
-                    primitives[i].setExtension(EXTENSION_NAME, this.create(model));
+        const root = context.jsonDoc.json.extensions?.[EXTENSION_NAME];
+        if (root) {
+            this.document.getRoot().setExtension(EXTENSION_NAME, this.create(root));
+        }
+        if (context.jsonDoc.json.meshes) {
+            context.meshes?.forEach((mesh, index) => {
+                const meshDefinition = context.jsonDoc.json.meshes[index];
+                if (!meshDefinition)
+                    return;
+                const primitives = mesh.listPrimitives();
+                for (let i = 0; i < primitives.length; i++) {
+                    const primitive = meshDefinition.primitives[i];
+                    if (primitive.extensions && primitive.extensions[EXTENSION_NAME]) {
+                        const model = primitive.extensions[EXTENSION_NAME];
+                        primitives[i].setExtension(EXTENSION_NAME, this.create(model));
+                    }
                 }
-            }
-        });
+            });
+        }
         return this;
     }
     write(ctx) {
@@ -36,7 +50,7 @@ export class NEEDLE_mesh_compression extends Extension {
 export class NEEDLE_mesh_compression_property extends ExtensionProperty {
     static EXTENSION_NAME = EXTENSION_NAME;
     extensionName = EXTENSION_NAME;
-    parentTypes = [PropertyType.PRIMITIVE];
+    parentTypes = [PropertyType.PRIMITIVE, PropertyType.ROOT];
     propertyType = EXTENSION_NAME;
     init() { }
     model;

package/dist/transforms/needle_common.d.ts

@@ -6,7 +6,7 @@ export interface NeedleTransformContext {
     noToktx: boolean;
 }
 export interface INeedleTextureTransformContext {
-    prepare(document: Document): Promise<void>;
+    prepare(document: Document): Promise<void | boolean>;
     process(index: number, texture: Texture, settings: NEEDLE_compression_texture_schema): Promise<boolean>;
     finalize(document: Document): Promise<void>;
 }

package/dist/transforms/needle_mesh_transform.js

@@ -1,67 +1,96 @@
 import { Primitive } from "@gltf-transform/core";
-import { simplifyPrimitive, SIMPLIFY_DEFAULTS, weldPrimitive, WELD_DEFAULTS } from "@gltf-transform/functions";
-import { MeshoptSimplifier } from "meshoptimizer";
+import { meshopt, simplifyPrimitive, SIMPLIFY_DEFAULTS, weldPrimitive, WELD_DEFAULTS, draco } from "@gltf-transform/functions";
+import { MeshoptEncoder, MeshoptSimplifier } from "meshoptimizer";
 import { NEEDLE_mesh_compression } from "../extensions/index.js";
-const NAME = 'needle_simplify';
+const NAME = 'needle_mesh_transform';
 export const needle_mesh_transform = function (_options) {
+    return async (document, _context) => {
+        await simplifierTransform(document, _context, _options);
+        await applyMeshCompression(document, _context);
+    };
+};
+async function applyMeshCompression(document, _context) {
+    const rootExtension = document.getRoot().getExtension(NEEDLE_mesh_compression.EXTENSION_NAME);
+    if (rootExtension) {
+        const rootModel = rootExtension.model;
+        if (rootModel.compression) {
+            if (rootModel.compression === "none") {
+                console.log(`[${NAME}]: NONE → will not apply mesh compression`);
+                return;
+            }
+            console.log(`[${NAME}]: ${rootModel.compression.toUpperCase()} → will apply ${rootModel.compression} mesh compression`);
+            if (rootModel.compression === "draco") {
+                const transform = draco();
+                return transform(document, _context);
+            }
+            else if (rootModel.compression === "meshopt") {
+                const transform = meshopt({ encoder: MeshoptEncoder });
+                return transform(document, _context);
+            }
+        }
+    }
+    // by default we still want to run draco if the root doesnt have a compression model configured
+    return draco()(document, _context);
+}
+async function simplifierTransform(document, _context, _options) {
     const simplifier = MeshoptSimplifier;
     if (!simplifier) {
-        throw new Error(`${NAME}: simplifier dependency required — install "meshoptimizer".`);
+        console.log(`WARN: [${NAME}] simplifier dependency required — install "meshoptimizer".`);
+        return false;
     }
-    return (document, _context) => {
-        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()) {
-            for (const prim of mesh.listPrimitives()) {
-                // 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
-                    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.`);
+    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()) {
+        for (const prim of mesh.listPrimitives()) {
+            // 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
+                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;
                 }
-                compressPrimitive(document, mesh, prim, weldOptions, simplifyOpts);
+                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, weldOptions, simplifyOpts);
         }
-    };
-};
+    }
+    return true;
+}
 function compressPrimitive(document, mesh, prim, weldOptions, meshOptions) {
     const logger = document.getLogger();
-    logger.debug(`${NAME}: Welding primitive of mesh "${mesh.getName()}" → tolerance: ${weldOptions.tolerance}`);
+    logger.debug(`[${NAME}]: Welding primitive of mesh "${mesh.getName()}" → tolerance: ${weldOptions.tolerance}`);
     weldPrimitive(document, prim, weldOptions);
-    logger.debug(`${NAME}: Simplifying primitive of mesh "${mesh.getName()}" → ratio: ${meshOptions.ratio}, error: ${meshOptions.error}, lockBorder: ${meshOptions.lockBorder}`);
+    logger.debug(`[${NAME}]: Simplifying primitive of mesh "${mesh.getName()}" → ratio: ${meshOptions.ratio}, error: ${meshOptions.error}, lockBorder: ${meshOptions.lockBorder}`);
     simplifyPrimitive(document, prim, meshOptions);
 }
 // function updatePrimitive(prim: Primitive, simplifier: any, positionArray, dstIndicesArray) {

package/dist/transforms/needle_texture_transform.js

@@ -131,8 +131,8 @@ async function processTexture(texture, index, document, logger, context) {
         if (canRunToktx) {
             // if no specific compression settings are provided we just use the toktx default settings
             // if we ever change what is used for default compression we need to teach the cache to save the mime type
-            await context.toktxContext.process(index, texture, null);
-            successFullyProcessed = true;
+            successFullyProcessed = await context.toktxContext.process(index, texture, null);
+            // don't add textures to the cache when toktx doesnt run
         }
         else {
             console.log("toktx is disallowed. Skipping texture compression.");

package/dist/transforms/needle_toktx.d.ts

@@ -19,7 +19,7 @@ export declare class NeedleToktxContext implements INeedleTextureTransformContex
     numTextures: number;
     private _prepareFailed;
     constructor(options: NeedleToktxOptions);
-    prepare(document: Document): Promise<void>;
+    prepare(document: Document): Promise<boolean>;
     process(index: number, texture: Texture, settings: NEEDLE_compression_texture_schema | null): Promise<boolean>;
     finalize(document: Document): Promise<void>;
 }

package/dist/transforms/needle_toktx.js

@@ -66,8 +66,9 @@ export class NeedleToktxContext {
             const logger = document.getLogger();
             this.version = await checkKTXSoftware(logger, this.env);
             if (this.version === null) {
+                console.log("Will not run toktx transform");
                 this._prepareFailed = true;
-                return;
+                return false;
             }
             this.basisuExtension = document.createExtension(KHRTextureBasisu).setRequired(true);
             const tmpDir = `${tmp.tmpdir}/gltf-transform`;
@@ -80,7 +81,9 @@ export class NeedleToktxContext {
             console.error(e);
             console.log("Error preparing toktx transform");
             this._prepareFailed = true;
+            return false;
         }
+        return true;
     }
     async process(index, texture, settings) {
         const task = async () => {

package/pack-gltf.mjs

@@ -112,7 +112,7 @@ async function packFile(file) {
             }),
             needle_mesh_transform({ ratio: 0.75, error: 0.0005 }),
             needle_animation_transform(),
-            draco(),
+            // draco(),
         );
         if (debug) file += ".debug.glb";
         await io.write(file, document);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@needle-tools/gltf-build-pipeline",
-  "version": "1.0.5",
+  "version": "1.1.0",
   "description": "Pipeline and tools for optimizing gltf files using gltf-transform and compression settings within glTF extensions",
   "main": "index.mjs",
   "type": "module",