app.ts

#!/usr/bin/env node

// Run with node, give a directory containing two or more glb files:
//   node app.ts /path/to/glb/directory
// or give a list of files to merge followed by the output file:
//   node app.ts run01.glb walk01.glb idle01.glb merged_output.glb

import { parseArgs } from 'node:util';
import path from 'node:path';
import * as fs from 'node:fs';
import { Document, NodeIO } from '@gltf-transform/core';
import { copyToDocument, dedup, prune, unpartition, flatten } from '@gltf-transform/functions';

async function loadGlb(io: NodeIO, filePath: string): Promise<Document> {
    const doc = await io.read(filePath);
    doc.getRoot().listScenes()[0].setName('Scene01');
    return doc;
}

function moveAnimations(targetDoc: Document, sourceDoc: Document) {
    const animations = sourceDoc.getRoot().listAnimations();
    copyToDocument(targetDoc, sourceDoc, animations);

    // relink animations to target joints
    const root = targetDoc.getRoot();
    const skins = root.listSkins();
    const joints = skins[0].listJoints();

    for (const anim of root.listAnimations()) {
        for (const channel of anim.listChannels()) {

            const targetNode = channel.getTargetNode();
            const matchJoint = joints.find(j => j.getName() === targetNode?.getName());

            if (matchJoint) {
                channel.setTargetNode(matchJoint);
            }
        }
    }
}

async function merge(inputPaths: string[], outputPath: string) {
    const io = new NodeIO();

    const mergeTarget = inputPaths.shift();
    if (mergeTarget) {

        const doc = await loadGlb(io, mergeTarget);

        for (const glb of inputPaths) {
            const doc2 = await loadGlb(io, glb);
            moveAnimations(doc, doc2);
        }

        await doc.transform(
            unpartition(),
            dedup(),
            flatten(),
            prune()
        );

        try {
            await io.write(outputPath, doc);
            console.log(`Exported merged gltf: ${outputPath}`);
        } catch (error) {
            console.log(`Could not write gtlf: ${error}`);
        }
    }
}

async function main() {
    // command line arguments
    const { positionals } = parseArgs({ allowPositionals: true, });

    if (positionals.length == 1) {
        // merge all the glbs in one directory
        const dir = positionals[0];
        if (fs.statSync(dir).isDirectory()) {

            const inputPaths = [];
            for (const fn of fs.readdirSync(dir)) {
                if (fn.endsWith('.glb')) {
                    const fullPath = path.join(dir, fn);
                    inputPaths.push(fullPath);
                }
            }
            
            if (inputPaths.length < 2) {
                console.log(`Too few glbs in directory, need at least two files to merge.`);
                return;
            }

            const outfile = path.basename(dir) + ".glb";
            const outputPath = path.join(path.dirname(dir), outfile);

            merge(inputPaths, outputPath);
        } 
        else {
            console.log(`Expected a directory of two or more glb files.`);
        }
    }
    else if (positionals.length >= 3) {
        // merge all the listed glbs into the output
        const outputPath = positionals.pop();
        const inputPaths = positionals;
        if (outputPath) {
            merge(inputPaths, outputPath);
        }
    } else {
        console.log(`Too few arguments, need at least two files to merge and an output file.`);
    }
}

main();