Through an editor utility Blueprint, you can run the MetaHuman performance solve. You can process many takes—mono footage, depth footage, or audio—and export the results as animation sequences.
This guide provides example snippets for processing MetaHuman performances and exporting the resulting animation using editor utility blueprints. The process is the same for Python. The MetaHuman Animator plugin ships example scripts in its Content/Python folder—see process_monocular_performance.py for a scripted equivalent of this workflow.
An existing ingest file is expected to process the performance assets. For more detailed information about how to download and ingest data using Blueprints, see Downloading and Ingesting Takes with CaptureManager in Unreal Editor.
Process and Create Animation Sequences
Every graph on this page starts from an editor utility Blueprint that holds a reference to a performance asset. If you do not have one, create it first. To learn more, see Scripting and Automating the Unreal Editor.
All three input types—mono footage, depth footage, and audio—use the same graph shape. The example snippets set a small number of properties on the MetaHuman Performance asset, start processing, wait for completion, then export.
You can set other variables shown in the snippets, such as the processing frame range. To see the full set of exposed properties, drag off a MetaHuman Performance pin in the graph editor, then check the Variables section of the context menu.
Not all variables apply to each processing mode, for example:
Depth processing range only affects depth footage processing.
Body tracking only affects mono footage processing.
From Mono Footage
To process Mono footage, set the following variables on the performance asset:
Set the input type to Monocular Footage.
Set Footage capture data to a valid Footage Capture Data asset containing at least one image sequence - this asset is usually generated as part of the ingest process.
You can also solve body animation from the same mono footage by enabling body tracking on the variable. Body tracking requires the MetaHuman Animator Markerless Motion Capture plugin—setting the variable without the plugin enabled has no effect.
The following blueprint snippet demonstrates ingesting mono footage, processing it, and exporting the animation sequence.
From Depth Footage
To process Depth-based footage, set the following variables on the performance asset:
Set the input type to Depth Footage.
Set Footage Capture Data to a valid footage capture data asset (stereo ingest path) containing at least two image sequences and a corresponding calibration. This asset is usually generated as part of the stereo ingest process.
Set Identity to a valid pre-prepared MetaHuman identity asset.
The following blueprint snippet demonstrates ingesting stereo footage, processing it, and exporting the animation sequence.
From Audio
To process Audio-only data (SoundWave assets), set the following variables on the performance asset:
Set the input type to Audio.
Set Audio to a valid sound wave asset.
The following blueprint snippet demonstrates taking a sound wave asset, processing it, and exporting the animation sequence.
Choose Blocking or Asynchronous Processing
Performance processing is asynchronous by default, and only one processing task runs at a time. That constraint shapes how you write any batch graph: you cannot start ten performances in parallel and wait for all of them.
You have the following options:
Set Blocking Processing to True on the performance asset. Execution does not continue until the solve finishes, so that you can wire the export step directly after the processing node. The cost is that the editor user interface (UI) is unresponsive for the duration of the solve.
Queue the tasks and chain them. Start one performance, wait for its completion event, then start the next. The editor stays responsive. To learn more, see the Manage the Performance Processing Queue Management section of this page.
For a large batch, blocking processing means the editor appears frozen for the entire run, not only for one take. For dozens of takes, that can be hours. Use the queue approach for anything you need to monitor, and reserve blocking processing for short runs or unattended commandlet-style jobs.
In Python, set blocking processing on the performance before processing: performance.set_blocking_processing(True).
Performance Processing Queue Management
This section is optional. It is only relevant if you intend to process performances while keeping the editor UI responsive.
When a performance processing task starts, it runs asynchronously in the background (unless you have enabled Blocking Processing); however, only a single performance processing task can run at a time.
To process multiple performances without blocking the UI, you must queue them up.
You can do this by binding to the On Processing Finished event for the first performance in the queue, then using that event to trigger processing of the next performance in the sequence, and so on, until all performances have been processed.
To start:
Add a variable in your Blueprint to track the list of pending performances. Name it Pending, and make it an array of MetaHuman Performance object references.
Populate Pending with the performances you want to process.
Get the first performance from the Pending array, bind to its OnCompleted event, and then start processing.
When OnCompleted is called, unbind the event from the completed performance, remove that performance from the Pending array, then bind the event to the next performance in the sequence and start processing that one.
The first stage can look something like this:
And the On Complete function can look something like this:
