How do you bake multiple animations at once?

[KnightNine]

It's tedious to have to go through every animation in the source armature and select "Bake into Action".
By default users would want their target armature to be able to copy all the animations on the source armature. Why is this so difficult to achieve?

I tried "Batch FBX Import and Bake" on my scene that I've exported as .FBX, but that only flooded my scene with animations that are tied to objects which are not animated. And none of these animations actually animate the target armature's bones.

Is there any solution to my issue?

[yohjimane]

I added something like this for some STALKER modding utility, i'll write another comment once the code is updated on my fork!

[milanwulf]

Here is a script I made, just enter your source and target armature names at the end and run the script.
Note that it will take some time depending on the amount of actions on the source armature, you can check the console for progress. But it would be nice to include this functionality in the addon.

import bpy

def clear_active_action(obj):
    """
    Clears the active action from the object's animation data.
    """
    if obj.animation_data:
        obj.animation_data.action = None

def set_active_action(obj, action):
    """
    Sets the specified action as the active action for the object.
    """
    if obj.animation_data:
        obj.animation_data.action = action

def stash_action(obj, action, track_name, start_frame):
    """
    Stashes an action into an NLA track.
    """
    tracks = obj.animation_data.nla_tracks
    new_track = tracks.new()
    new_track.name = track_name
    strip = new_track.strips.new(action.name, start_frame, action)
    new_track.lock = True
    new_track.mute = True
    obj.animation_data.action = None
    return new_track

def unmute_nla_tracks(obj):
    """
    Unmutes all NLA strips on the specified object.
    """
    if obj.animation_data and obj.animation_data.nla_tracks:
        for track in obj.animation_data.nla_tracks:
            track.mute = False

def disable_bone_drivers(target_armature):
    """
    Disables the bone drivers in the retargeting addon for the target armature.
    """
    bpy.context.view_layer.objects.active = target_armature
    bpy.ops.drivers.disable()

def retarget_nla_tracks(source_armature, target_armature):
    # Ensure both source and target armatures exist
    if not (source_armature and target_armature):
        print("Error: Both source and target armatures must be specified.")
        return

    # Access the NLA tracks of the source armature
    nla_tracks = source_armature.animation_data.nla_tracks

    for track in nla_tracks:
        # Ensure the track has an action
        if not track.strips or not track.strips[0].action:
            print(f"Skipping NLA Track '{track.name}': No associated action.")
            continue

        action = track.strips[0].action

        # Set the source armature's active action
        set_active_action(source_armature, action)

        # Retarget to the target armature
        bpy.context.view_layer.objects.active = target_armature
        bpy.ops.object.mode_set(mode='POSE')  # Switch to Pose Mode
        bpy.ops.baking.bake()  # Bake the action using the addon

        # Re-enable drivers using the correct operator
        bpy.ops.drivers.enable()

        # Stash the baked action into the target armature's NLA
        track_name = f"Baked_{action.name}"
        stash_action(target_armature, target_armature.animation_data.action, track_name, 1)

        # Clear the active action after stashing
        clear_active_action(target_armature)

        # Print a console message
        print(f"Baked and stashed NLA Track: '{track.name}' with Action: '{action.name}' to Target Armature")

        # Clear the source armature's active action
        clear_active_action(source_armature)

        # Reset to Object Mode
        bpy.ops.object.mode_set(mode='OBJECT')

    # Disable bone drivers after all tracks are processed
    disable_bone_drivers(target_armature)

    # Unmute all NLA strips on the target armature
    unmute_nla_tracks(target_armature)

    print("Retargeting completed.")

# Example usage:
# Replace 'Armature' and 'Armature.001' with the actual names of your source and target armatures
source_armature_name = "Mixamo_Armature"
target_armature_name = "HG_Teresa_V2.002"

source_armature = bpy.data.objects.get(source_armature_name)
target_armature = bpy.data.objects.get(target_armature_name)

retarget_nla_tracks(source_armature, target_armature)