@needle-tools/gltf-build-pipeline 1.5.0-alpha.7 → 1.5.0-alpha.9

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.5.0-alpha.9] - 2023-05-16
+- add: start of VRM 1.0 support. Not implemented is the `VRMC_materials_mtoon` extension 
+
+## [1.5.0-alpha.8] - 2023-05-16
+- fix: issue where updating ktx compressed texture extension also flattened the path
+
 ## [1.5.0-alpha.7] - 2023-05-16
 - fix: external resources that are KTX2 compressed are now saved with a `.ktx2` extension
 - change: toktx now uses compression "auto" mode to select uastc or etc1s 

package/dist/extensions/NEEDLE_opaque/NEEDLE_opaque.d.ts

@@ -1,9 +1,10 @@
 import { WriterContext, PropertyType } from '@gltf-transform/core';
 declare interface IExtensibleProperty {
 }
+type DebugBreakPoint = boolean | "pointer:read";
 export type Options = {
     debug?: boolean;
-    breakpoint?: boolean;
+    breakpoint?: DebugBreakPoint;
     write?: boolean;
 };
 export interface IOpaqueExtension {

package/dist/extensions/NEEDLE_opaque/NEEDLE_opaque.js

@@ -26,6 +26,7 @@ export function createOpaqueExtension(name, types, opts) {
                 console.log("READ " + EXTENSION_NAME);
             this.jsonPointerHandler = new JsonPointerHandler(this.document, EXTENSION_NAME);
             this.jsonPointerHandler.debug = debugLog;
+            this.jsonPointerHandler.breakPoint = opts.breakpoint;
             for (const type of types) {
                 switch (type) {
                     case PropertyType.ACCESSOR:
@@ -514,6 +515,7 @@ class JsonPointerHandler {
     document;
     map = new Map();
     debug = false;
+    breakPoint = false;
     constructor(document, id) {
         this.document = document;
         this.id = id;
@@ -524,7 +526,11 @@ class JsonPointerHandler {
         if (key !== undefined) {
             fullPath ??= "";
             fullPath += "/" + key;
+            if (this.breakPoint === "pointer:read") {
+                debugger;
+            }
         }
+        // if(this.debug && key === "colliders") debugger;
         switch (typeof value) {
             case 'object':
                 if (value !== null && value !== undefined) {
@@ -570,7 +576,7 @@ class JsonPointerHandler {
                         if (pointer) {
                             if (this.debug)
                                 console.log("> Register pointer", this.id + "/" + fullPath + " : " + value);
-                            pointer?.register(obj, key);
+                            pointer?.register(obj, key, fullPath);
                         }
                         else
                             console.warn("WARN: failed registering pointer", fullPath, value);
@@ -597,13 +603,15 @@ class JsonPointerHandler {
                                 pointer.debug = this.debug;
                                 this.map.set(value, pointer);
                             }
-                            pointer?.register(obj, key);
+                            pointer?.register(obj, key, fullPath);
                         }
                     }
                 }
                 break;
             case 'number':
-                if (key === "node" || key === "mesh") {
+                if (key === "node" || key === "mesh"
+                    // VRM 1.0 spring bone center https://github.com/vrm-c/vrm-specification/blob/master/specification/VRMC_springBone-1.0/schema/VRMC_springBone.spring.schema.json
+                    || fullPath.match(/springs\/\d+\/center/g)) {
                     const object = context.nodes[value];
                     if (object) {
                         const res = new NodeIndexResolver(this.document, object, context.jsonDoc.json.nodes[value]);
@@ -615,12 +623,17 @@ class JsonPointerHandler {
                             pointer = new JsonPointer(null, res, value);
                         }
                         pointer.debug = this.debug;
-                        pointer.register(obj, key);
+                        pointer.register(obj, key, fullPath);
                         this.map.set(dictKey, pointer);
                     }
                 }
-                // key texture is matching for example for VRM meta/texture (AvatarSample_A) and the regex is also for handling VRM material properties
-                else if (key === "texture" || fullPath.match(/materialProperties\/\d+?\/textureProperties/g)) {
+                else if (
+                // key texture is matching for example for VRM meta/texture (AvatarSample_A)
+                key === "texture"
+                    // VRM 0.0 material properties
+                    || fullPath.match(/materialProperties\/\d+\/textureProperties/g)
+                    // VRM 1.0 meta
+                    || fullPath.match(/meta\/thumbnailImage/g)) {
                     const index = value;
                     // e.g. in meta.texture for VRM avatars it seems like we can have negative values
                     if (index < 0) {
@@ -648,7 +661,7 @@ class JsonPointerHandler {
                             pointer = new JsonPointer(null, res, value);
                         }
                         pointer.debug = this.debug;
-                        pointer.register(obj, key);
+                        pointer.register(obj, key, fullPath);
                         this.map.set(dictKey, pointer);
                         if (ext) {
                             ext.setReference(dictKey, object);
@@ -656,6 +669,8 @@ class JsonPointerHandler {
                     }
                 }
                 break;
+            default:
+                break;
         }
     }
     resolveAndWrite(context) {
@@ -677,9 +692,11 @@ class JsonPointer {
     }
     _objects = [];
     _props = [];
-    register(obj, prop) {
+    _debugInfo = [];
+    register(obj, prop, fullpath) {
         this._objects.push(obj);
         this._props.push(prop);
+        this._debugInfo.push(fullpath);
     }
     newPointer;
     resolve(context) {
@@ -694,18 +711,19 @@ class JsonPointer {
                 this.newPointer = index;
             }
             if (this.debug)
-                console.log(`RESOLVED ${this.oldPointer} to → ${this.newPointer}`);
+                console.log(`RESOLVED pointer ${this.oldPointer} to → ${this.newPointer}`);
         }
         else {
-            console.log("ERR: failed to resolve pointer", this.pointerBase);
+            console.log("ERR: 🧨 FAILED to resolve pointer", this.pointerBase, ` used by ${this._debugInfo.join(", ")}`);
         }
     }
     write() {
         for (let i = 0; i < this._objects.length; i++) {
             const obj = this._objects[i];
             const prop = this._props[i];
-            if (this.debug)
-                console.log("< Resolved pointer", this.newPointer, "in", prop);
+            if (this.debug) {
+                console.log(`< Resolved pointer ${this._debugInfo[i]}: ${this.newPointer}`);
+            }
             obj[prop] = this.newPointer;
         }
     }

package/dist/extensions/NEEDLE_opaque/index.js

@@ -17,5 +17,12 @@ export const ALL_EXTENSIONS = [
     createOpaqueExtension("EXT_texture_exr", [PropertyType.TEXTURE], { ...opaqueOptions }),
     createOpaqueExtension("NEEDLE_editor", [PropertyType.NODE, PropertyType.MATERIAL], { ...opaqueOptions }),
     createOpaqueExtension("NEEDLE_gltf_dependencies", [PropertyType.ROOT], { ...opaqueOptions }),
+    // VRM 0.0
     createOpaqueExtension("VRM", [PropertyType.ROOT], { ...opaqueOptions }),
+    // VRM 1.0 https://vrm.dev/en/vrm1/changed/
+    createOpaqueExtension("VRMC_vrm", [PropertyType.ROOT], { ...opaqueOptions }),
+    createOpaqueExtension("VRMC_springBone", [PropertyType.ROOT], { ...opaqueOptions }),
+    createOpaqueExtension("VRMC_node_constraint", [PropertyType.NODE], { ...opaqueOptions }),
+    // TODO: mtoon materials don't work yet
+    // createOpaqueExtension("VRMC_materials_mtoon", [PropertyType.MATERIAL], { ...opaqueOptions, debug: true, breakpoint: "pointer:read" },),
 ];

package/dist/transforms/needle_texture_transform.js

@@ -76,8 +76,8 @@ export const needle_texture_transform = function (options) {
     });
 };
 async function processTexture(texture, index, document, logger, context) {
-    const mimeType = texture.getMimeType();
-    const isSupported = mimeType === "image/jpeg" || mimeType === "image/png" || mimeType === "image/webp";
+    const originalMimeType = texture.getMimeType();
+    const isSupported = originalMimeType === "image/jpeg" || originalMimeType === "image/png" || originalMimeType === "image/webp";
     // dont try to transform EXR or already processed textures
     if (!isSupported)
         return;
@@ -128,7 +128,10 @@ async function processTexture(texture, index, document, logger, context) {
         }
     }
     else {
-        let mimetype = "image/ktx2";
+        let mimeType = "image/ktx2";
+        // const slots = listTextureSlots(texture);
+        // if (slots.includes("metallicRoughnessTexture"))
+        //     mimeType = "image/webp";
         const isVRM = context.file?.toLowerCase().endsWith(".vrm");
         // TODO: need to make this into a function
         // const webpThreshold = 256; // this is the default threshold in progressive textures (needle_progressive.ts)
@@ -144,12 +147,14 @@ async function processTexture(texture, index, document, logger, context) {
         // If we have a texture cached we can use it
         // the default compression is toktx so we can safely use that for now
         if (cached) {
-            texture.setImage(cached).setMimeType(mimetype);
+            texture.setImage(cached).setMimeType(mimeType);
             return;
         }
         await resizeTextureIfNecessary(texture);
         if (mimeType === "image/webp") {
-            successFullyProcessed = await context.webPContext.process(index, texture, null);
+            successFullyProcessed = await context.webPContext.process(index, texture, {
+                quality: .9,
+            });
         }
         else if (canRunToktx) {
             // if no specific compression settings are provided we just use the toktx default settings

package/dist/transforms/needle_toktx.js

@@ -8,6 +8,7 @@ import fs from 'fs/promises';
 import os from 'os';
 import tmp from 'tmp';
 import pLimit from 'p-limit';
+import { replaceExtension } from "../utils/fileutils.js";
 const NUM_CPUS = os.cpus().length || 1; // microsoft/vscode#112122
 let didLogEnvironmentInfo = false;
 export class NeedleToktxContext {
@@ -126,9 +127,12 @@ export class NeedleToktxContext {
                 }
             }
             else if (slots) {
-                const betterQuality = slots.includes("normalTexture") || slots.includes("metallicRoughnessTexture");
+                const isNormal = slots.includes("normalTexture");
+                const isMetallicRoughness = slots.includes("metallicRoughnessTexture");
+                const betterQuality = isNormal || isMetallicRoughness;
                 // mode = useUASTC ? Mode.UASTC : Mode.ETC1S;
                 mode = Mode.ETC1S;
+                // if (isMetallicRoughness) mode = Mode.UASTC;
                 // https://github.khronos.org/KTX-Software/ktxtools/toktx.html
                 quality = betterQuality ? 255 : 128;
                 // ETC1S / BasisLZ compression level, an encoding speed vs. quality tradeoff. Range is [0,5], default is 1. Higher values are slower but give higher quality.
@@ -158,7 +162,7 @@ export class NeedleToktxContext {
                     // If this is a texture that was loaded from a file, we need to update the URI
                     if (texture.getURI()) {
                         const oldUri = texture.getURI();
-                        const newUri = FileUtils.basename(oldUri) + '.ktx2';
+                        const newUri = replaceExtension(oldUri, 'ktx2');
                         texture.setURI(newUri);
                     }
                     return true;

package/dist/transforms/needle_webp.d.ts

@@ -8,6 +8,6 @@ export declare class NeedleWebPContext implements INeedleTextureTransformContext
     logger: ILogger;
     constructor(options: NeedleWebPOptions);
     prepare(document: Document): Promise<void>;
-    process(index: number, texture: Texture, settings: NEEDLE_compression_texture_schema): Promise<boolean>;
+    process(index: number, texture: Texture, settings: Pick<NEEDLE_compression_texture_schema, "quality">): Promise<boolean>;
     finalize(document: Document): Promise<void>;
 }

package/dist/utils/fileutils.d.ts

@@ -1,2 +1,3 @@
 export declare type GLTFFileCallback = (file: string) => void | Promise<void>;
 export declare function foreachGLTF(args: string | string[], callback: GLTFFileCallback): Promise<void>;
+export declare function replaceExtension(filepath: string, newExtension: string): string;

package/dist/utils/fileutils.js

@@ -113,3 +113,8 @@ async function testEntry(entry, callback, context) {
         }
     }
 }
+export function replaceExtension(filepath, newExtension) {
+    const parts = filepath.split(".");
+    parts.pop();
+    return parts.join(".") + "." + newExtension;
+}

package/package.json

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