Removing animation channels with the same target

[kzhsw]

This is a quick fix to ANIMATION_DUPLICATE_TARGETS of glTF-Validator.
This removes animation channels that have the same target as other ones in the same animation.
Options available for different modes:

• first: keep the first found channel, remove remaining
• last: keep the last found channel, remove remaining (default)
• longest: keep the longest channel (by frame time), remove remaining
• shortest: keep the longest channel (by frame time), remove remaining

Code

import {createTransform} from "@gltf-transform/functions";

const NAME = 'animationDedupTarget';

const DEFAULT_OPTIONS = {
    /**
     * Options for animation channels whose sampler has one frame or 2 identical frames
     * where the frame values differ from targetNode.
     * @default 'keep'
     * @type {'first' | 'last' | 'longest' | 'shortest' }
     */
    mode: 'last',
};

/**
 * Remove animation channels that have the same target as other ones in the same animation.
 *
 * @see https://github.com/KhronosGroup/glTF-Validator/blob/2.0.0-dev.3.8/ISSUES.md?plain=1#L86
 * @param _options
 * @return {import('@gltf-transform/core').Transform}
 */
export function animationDedupTarget(_options = DEFAULT_OPTIONS) {
    const options = {...DEFAULT_OPTIONS, ..._options};
    return createTransform(NAME, (doc) => {
        const root = doc.getRoot();
        const animations = root.listAnimations();
        /**
         * @type {Map<import('@gltf-transform/core').Node, Record<string, import('@gltf-transform/core').AnimationChannel[]>>}
         */
        const map = new Map();
        for (let i = 0, length = animations.length; i < length; i++) {
            const animation = animations[i];
            const channels = animation.listChannels();
            for (let j = 0, cLength = channels.length; j < cLength; j++) {
                const channel = channels[j];
                const targetNode = channel.getTargetNode();
                // TODO: animation_pointer
                const targetPath = channel.getTargetPath();
                // animations without target should be removed with `prune`
                if (!targetNode || !targetPath || targetPath === 'pointer') {
                    continue;
                }
                let propMap = map.get(targetNode);
                if (!propMap) {
                    propMap = {};
                    map.set(targetNode, propMap);
                }
                let channelList = propMap[targetPath];
                if (!channelList) {
                    channelList = [];
                    propMap[targetPath] = channelList;
                }
                channelList.push(channel);
            }
            for (const propMap of map.values()) {
                for (const targetPath in propMap) {
                    const channelList = propMap[targetPath];
                    if (channelList.length <= 1) {
                        continue;
                    }
                    let channelsToDispose = [];
                    let keepIndex = -1;
                    let keepValue = 0;
                    const tmpArr = [];
                    switch (options.mode) {
                        case "first":
                            channelsToDispose = channelList.slice(1);
                            break;
                        case "last":
                            channelsToDispose = channelList.slice(0, -1);
                            break;
                        case "longest":
                            keepValue = -Infinity;
                            for (let j = 0; j < channelList.length; j++) {
                                const channel = channelList[j];
                                const sampler = channel.getSampler();
                                if (sampler) {
                                    sampler.getInput().getMax(tmpArr);
                                    if (tmpArr[0] > keepValue) {
                                        keepValue = tmpArr[0];
                                        keepIndex = j;
                                    }
                                }
                            }
                            if (keepIndex >= 0) {
                                channelsToDispose = channelList.filter(
                                    (_, index) => index !== keepIndex);
                            }
                            break;
                        case "shortest":
                            keepValue = Infinity;
                            for (let j = 0; j < channelList.length; j++) {
                                const channel = channelList[j];
                                const sampler = channel.getSampler();
                                if (sampler) {
                                    sampler.getInput().getMax(tmpArr);
                                    if (tmpArr[0] < keepValue) {
                                        keepValue = tmpArr[0];
                                        keepIndex = j;
                                    }
                                }
                            }
                            if (keepIndex >= 0) {
                                channelsToDispose = channelList.filter(
                                    (_, index) => index !== keepIndex);
                            }
                            break;
                    }
                    if (channelsToDispose.length) {
                        channelsToDispose.forEach(c => c.dispose());
                    }
                }
            }
            map.clear();
        }
    });
}