@needle-tools/gltf-build-pipeline 1.2.3 → 1.3.0

package/CHANGELOG.md

@@ -4,6 +4,13 @@ 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.3.0] - 2023-10-20
+- fix: meshopt with khr_animation_2 extension was not correctly processed: animated node and target were not passed to gltf-transform which caused a wrong processing of meshopt. We now pass this information to the gltf-transform AnimationChannel object
+- change: bump gltf-transform to 3.7.3
+
+## [1.2.4] - 2023-09-30
+- fix: bug in progressive texture transform where extension wasnt added correctly (NE-3627)
+
 ## [1.2.3] - 2023-09-29
 - fix: bug in progressive texture transform where texture wasnt found
 

package/dist/extensions/NEEDLE_opaque/NEEDLE_opaque.js

@@ -33,12 +33,23 @@ export function createOpaqueExtension(name, types, opts) {
                     case PropertyType.ANIMATION_CHANNEL:
                         if (EXTENSION_NAME === "KHR_animation_pointer") {
                             context.jsonDoc.json.animations?.forEach((animDef, animIndex) => {
+                                const anim = context.animations[animIndex];
+                                const channels = anim.listChannels();
                                 animDef.channels?.forEach((channel, channelIndex) => {
                                     const jsonTarget = channel.target;
                                     const khr_animation = jsonTarget.extensions && jsonTarget.extensions[EXTENSION_NAME];
                                     if (!khr_animation)
                                         return;
-                                    const anim = context.animations[animIndex];
+                                    const pointer = khr_animation.pointer;
+                                    if (pointer) {
+                                        const sections = pointer.split("/");
+                                        const nodeIndex = parseInt(sections[2]);
+                                        const targetName = sections[3];
+                                        if (targetName === "scale" || targetName === "translation" || targetName === "rotation") {
+                                            channels[channelIndex].setTargetNode(context.nodes[nodeIndex]);
+                                            channels[channelIndex].setTargetPath(targetName);
+                                        }
+                                    }
                                     const existing = anim.getExtension(EXTENSION_NAME);
                                     if (debugLog)
                                         console.log(">>>", EXTENSION_NAME, "animation", animIndex, "channel", channelIndex, khr_animation);

package/dist/extensions/NEEDLE_progressive_texture_settings/index.js

@@ -10,17 +10,40 @@ export class NEEDLE_progressive_texture_settings extends Extension {
             return this;
         const root = this.document.getRoot();
         const textures = root.listTextures();
+        /**
+         * If a texture is used in multiple slots it only appears once in the gltf-transform list
+         * So we have to store the key and the index of the texture in the list
+         */
+        const textureMap = new Map();
+        let offset = 0;
         for (let i = 0; i < textureDefinitions.length; i++) {
             const texDef = textureDefinitions[i];
             if (texDef.extensions && texDef.extensions[EXTENSION_NAME]) {
                 const ext = texDef.extensions[EXTENSION_NAME];
                 const prop = new NEEDLE_progressive_texture_settings_property(this.document.getGraph(), "");
                 Object.assign(prop, ext);
-                const tex = textures[i];
+                let textureIndex = i - offset;
+                const key = ext.guid;
+                if (textureMap.has(key)) {
+                    // we keep a track of the index offset assuming gltf-transform textures order is the same as the texture definition order. This is by no means *not* bullet-proof but I'm not sure how to do it properly right now
+                    // Perhaps we could try to find the texture with the same image source binary array as defined in the texture definition but this would also not be perfect I think...
+                    // TODO: find a better way to handle texture definition count and texture count mismatch due to a texture being used in multiple slots (where gltf-transform optimizes the texture list and removes duplicates) 
+                    offset += 1;
+                    // textureIndex = textureMap.get(key);
+                    console.log(`INFO: Progressive texture extension was ${i} already found...`);
+                    continue;
+                }
+                else {
+                    textureMap.set(key, textureIndex);
+                }
+                const tex = textures[textureIndex];
                 if (tex)
                     tex.setExtension(EXTENSION_NAME, prop);
                 else {
-                    console.warn("Texture not found for texture index " + i);
+                    // console.log(textureDefinitions)
+                    console.warn(`WARN: Progressive texture at index ${i} was not found in the glTF file. This might result in falsely loaded textures for ${ext.guid} / name \"${texDef.name}\"`);
+                    // if(debug)
+                    // throw new Error(`Progressive texture at index ${i} was not found in the glTF file.`)
                 }
             }
         }

package/dist/transforms/needle_progressive.js

@@ -101,37 +101,37 @@ export function make_progressive_textures(filePath, _options = TEXTURE_RESIZE_DE
             const uri = texture.getURI();
             const match = !options.pattern || options.pattern.test(name) || options.pattern.test(uri);
             if (!match) {
-                logger.debug(`${NAME}: Skipping, excluded by "pattern" parameter.`);
+                logger.debug(`${NAME}: Skipping, excluded by "pattern" parameter. ${textureIndex}`);
                 continue;
             }
             if (texture.getMimeType() !== 'image/png' && texture.getMimeType() !== 'image/jpeg') {
-                logger.warn(`${NAME}: Skipping, unsupported texture type "${texture.getMimeType()}".`);
+                logger.warn(`${NAME}: Skipping, unsupported texture type "${texture.getMimeType()} at ${textureIndex}".`);
                 continue;
             }
             const slots = listTextureSlots(texture);
             if (options.slots && !slots.some((slot) => options.slots?.test(slot))) {
-                logger.debug(`${NAME}: Skipping, [${slots.join(', ')}] excluded by "slots" parameter.`);
+                logger.debug(`${NAME}: Skipping, [${slots.join(', ')}] excluded by "slots" parameter. ${textureIndex}`);
                 continue;
             }
             const settings = texture.getExtension(NEEDLE_progressive_texture_settings.EXTENSION_NAME);
             if (!settings) {
-                logger.warn(`${NAME}: Skipping, no settings found`);
+                logger.warn(`${NAME}: Skipping, no settings found ${textureIndex}`);
                 continue;
             }
             if (!settings.isValid) {
-                logger.warn(`${NAME}: Skipping, settings are invalid`);
+                logger.warn(`${NAME}: Skipping, settings are invalid ${textureIndex}`);
                 continue;
             }
             options.size[0] = settings.maxSize;
             options.size[1] = settings.maxSize;
             const existingExtension = texture.getExtension(NEEDLE_PROGRESSIVE_TEXTURE_EXTENSION_NAME);
             if (existingExtension !== undefined && existingExtension !== null) {
-                logger.debug(`${NAME}: Skipping, texture is already progressive`);
+                logger.debug(`${NAME}: Skipping, texture is already progressive ${textureIndex}`);
                 continue;
             }
             const progressiveExt = doc.createExtension(NEEDLE_progressive);
             if (!progressiveExt || !progressiveExt.create) {
-                logger.debug(`${NAME}: Skipping because progressive extension is not available.`);
+                logger.debug(`${NAME}: Skipping because progressive extension is not available. ${textureIndex}`);
                 continue;
             }
             const textureGuid = settings.guid?.length ? settings.guid : generateGuid();
@@ -253,7 +253,7 @@ async function resizeTexture(options, texture, logger, uri, slots) {
     const [maxWidth, maxHeight] = options.size;
     const [srcWidth, srcHeight] = texture.getSize();
     if (srcWidth <= maxWidth && srcHeight <= maxHeight) {
-        logger.debug(`${NAME}: Skipping, not within size range.`);
+        logger.debug(`${NAME}: Skipping, the texture is already smaller than the requested size ${maxWidth}x${maxHeight}}`);
         return;
     }
     if (maxWidth <= 0 || maxHeight <= 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@needle-tools/gltf-build-pipeline",
-  "version": "1.2.3",
+  "version": "1.3.0",
   "description": "Pipeline and tools for optimizing gltf files using gltf-transform and compression settings within glTF extensions",
   "main": "index.mjs",
   "type": "module",
@@ -16,9 +16,9 @@
     "compile": "tsc || exit 1"
   },
   "dependencies": {
-    "@gltf-transform/core": "^3.4.6",
-    "@gltf-transform/extensions": "^3.4.6",
-    "@gltf-transform/functions": "^3.4.6",
+    "@gltf-transform/core": "^3.7.3",
+    "@gltf-transform/extensions": "^3.7.3",
+    "@gltf-transform/functions": "^3.7.3",
     "command-exists": "^1.2.9",
     "command-line-args": "^5.2.1",
     "draco3dgltf": "^1.5.3",