Exporting Root Motion from Blender to Unreal

At the end of this article, you should be able to:

• Understand the basic of Blender's Armature system.

• Understand how to rig a character with root bone in Blender that can be exported to Unreal Engine.

• Understand how to animate and export a character with root motion from Blender to Unreal.

• Understand the difference between Object Mode and Pose Mode in Blender.

• Understand how to export a root motion using two different methods: Object Mode and Pose Mode.

  
  

Did you know you don’t need to animate the Armature object in Blender to get a character’s root motion in Unreal Engine? Yeah, you read that right. When animating a character in Blender, you don’t need to switch to Object Mode to animate the root motion of your character. Since Engine version 4.24+, Unreal ignores the Armature object when you import an FBX file from Blender containing a skeletal mesh or its animation. But there is a catch to make it work, and the key is how you name the Armature object.

It’s common to see people struggle when animating a game character in Blender that needs root motion to be exported to a game engine such as Unreal. I was one of those people too. We often ended up having to animate the Armature object in Blender to achieve the desired root motion of the character in Unreal. This meant needed to switch from Pose mode to Object mode in Blender and animating the Armature object itself. A time-consuming process that can also be confusing and complicated, especially when the local space orientation of the root bone doesn’t match the local space orientation of the Armature object.

But why is necessary in Blender to animate the Armature object in Object Mode to obtain a root motion? In Blender, the Armature object holds the data related to the skeletal mesh, and the skeleton hierarchy is a child of that Armature object. Wherever we put the Armature object, the skeleton will follow. Because of that, when importing a character’s skeletal mesh from Blender, Unreal used to interpret the Armature object as the first bone of the skeleton hierarchy, what we would call the root bone. However, since Engine 4.24+, Unreal has been programmed to ignore the Armature object, making only the bones themselves part of the character’s skeleton in Unreal.

In this process, naming is a crucial step when creating a character rig in Blender if you need to export the root motion. In fact, naming is one of the most important steps when exporting and importing skeletal meshes and animations between different software. To ensure that Unreal ignores the Armature object, you must keep the Armature object named “Armature” in Blender. If you change the name “Armature” to anything else, Unreal will interpret the Armature object as the first bone of your skeletal mesh.

Still confused? Let’s take a closer look on the entire process. We are going to start by examining how the Armature system works in Blender. After that, we’ll test how the root motion behaves by exporting a character rig and its animation from Blender, then importing them into Unreal. What happens if we keep the Armature object named “Armature”? And what happens if we change its name for something else?

When we create an Armature in Blender, it gives us a single bone in the viewport. And we are going to be seeing this bone in Object Mode. However, if we take a closer look in the Outliner, we’ll notice that Blender actually creates four different elements:

- Armature object: orange, thick stick-figure icon.

- Armature data-block: green stick-figure holding a ball icon.

- Bone itself: green bone icon.

- Pose data-block: green running stick-figure icon.

In short, the Armature object serves as the container for all the other elements. If you look at the Outliner, you’ll see that all the other elements are children of the Armature object. If you move, rotate, scale the Armature object, all of its children will be affected. Everything we do in Object Mode is going to affect the Armature object, the orange thick stick-figure. (See image below.)

If you notice in the Outliner, you’ll notice that the Bone itself is a child of the Armature data-block. The Armature data-block stores all the data related to the bones in their rest pose. When you switch to Edit Mode to adjust the bones of your character’s skeleton, the Armature data-block becomes active and stores all the edited bone data. (See the next two images below.) Edit Mode is the mode that a rigger would use to create and edit the entire skeleton of a character rig.

Each bone you create is going go be represented by a green bone icon in the Outliner, and each one of them is a part of your character’s skeleton. If you switch to Pose Mode, you’ll notice that the bone becomes a child of the Pose data-block. The Pose data-block becomes active, and stores all pose and animation data that you create for your character. (See the next two images below.)

So, when we need to animate a rigged character in Blender, we animate the bones by accessing the Pose Mode. The Pose Mode is specifically used for animating the bones of a rigged character. While we often use controls to animate the bones, for this article we’ll focus directly on the bones themselves. The way controls work in Blender is a bit different from other DCC tools like Maya. In Blender, the controls are basically the bones themselves but displayed as curves. We’ll leave this discussion for other occasion.

It's also possible in Blender to animate objects like cubes, spheres, character meshes, empties and the Armature object itself. We call it Armature object for one reason, because it behaves like those other objects mentioned. To animate those objects, we need to switch to Object Mode. This is how an animator would proceed to create root motion of the character by animating the Armature object. When doing so, both data-blocks (Armature data-block and Pose data-block) are affected as well, since they are children of the Armature object. Wherever the Armature object goes, the skeleton follows. In short, to animate the Armature object we need to be in Object Mode, and animating the Armature also affects both data-blocks and the bones.

Alright, so now that we understand the basics of how the Armature system works in Blender, let’s se how to set up a character rig for export with root motion to Unreal. Of those four elements created when making an Armature, the two important ones for this process are the Armature Object and the Bones of the character’s skeleton. The Armature data-block and the Pose data-block do not affect the export process.

The character we’ll use here is the Female Anti-Mage from Dota 2. The character rig was adapted to have a skeleton with a root bone set at the world origin – the common setup for a game-ready character. The root bone is named “root”, and the pelvis bone is a child of the root bone. From the pelvis, the rest of the skeleton is connected, including the spine, legs, and other secondary parts such as cloth.

Let’s first export the skeletal mesh from Blender and import it into Unreal. What happens if we keep the Armature object named “Armature”? And what happens if we rename the Armature object to something else?

If we keep the Armature object named “Armature” and export the skeletal mesh from Blender into Unreal, the Engine ignores the Armature object. The result in Unreal is a skeleton with the bone named “root” as the first bone in the hierarchy. (In the two images below, we can see the skeleton structure and the Armature object in Blender’s Outliner, as well as the skeleton hierarchy in Unreal after the character rig has been exported to the engine.)

On the other hand, if we rename the Armature object to something else, when we import it into Unreal, the Engine is going to interpret the Armature object as a bone in the skeleton hierarchy. For example, if we rename the Armature object to “Character_Armature” in Blender, it becomes the first bone in the skeleton hierarchy in Unreal, effectively making the Armature object the root bone of the character’s skeletal mesh in Unreal. The bone we named “root” then becomes the second bone in the skeleton hierarchy. (In the next two images, the Armature object has been renamed to “Character_Armature” in Blender, and the new skeleton hierarchy in Unreal gets the “Character_Armature” as the root bone.)

Here is an important concept you must understand before we continue. The root bone in a skeleton is simply the first bone in the skeleton hierarchy. The fact that a bone is named “root” doesn’t automatically make it the root of the skeleton. It only becomes the root it is the first bone in the skeleton hierarchy. For game characters, the root bone is usually set at the world origin. So when we talk about root motion, we are referring to the motion of the first bone in the skeleton hierarchy. Keep that in mind.

So, what is the implication of having the Armature object as the first bone in the skeleton hierarchy in Ureal? The implication is that when animating in Blender, the animator must animate the Armature object itself to generate the root motion in Unreal. This requires switching from Pose Mode to Object Mode and animating the Armature object directly.

However, if we keep the Armature object named “Armature” in Blender, Unreal ignores the Armature object. In this case, the first bone in the skeleton hierarchy in Blender, the one we named “root”,becomes the first bone in the skeleton hierarchy in Unreal. This bone effectively becomes the root bone of the skeleton in Unreal. The implication is that the animator in Blender can stay in Pose Mode and animate the bone named “root” to achieve the desired root motion in Unreal.

Confusing? Let’s look at a simple root motion example with our Anti-Mage character. In the image below, the bone “root” is animated in Blender, translating the character forward, while the Armature object remains named “Armature”.

What’s happening is that the bone “root” is translating forward, while the “Armature” object remains in place at the world origin because we didn’t animate it. The orange arrow, in the image below, points to the position of the Armature object. And the pink arrow points to the position of the bone “root” after it has moved forward.

Remember, if we keep the Armature object named “Armature”, Unreal will ignore it and it is going to make the bone “root” the first bone in the skeleton hierarchy. When we export this animation to Unreal Engine, we get the desired root motion, meaning the first bone in the skeleton hierarchy will be the one moving forward. In the GIF below,the “root” bone is selected, it is the first bone of the hierarchy and it is moving forward.

An important note here: you probably noticed a red line in the GIF above. This line connects the starting location of the root bone to all its subsequent positions in the animation. This is what we call the root motion trajectory or root motion path.

On the other hand, if we export this same animation but now rename the Armature object to “Character_Armature”, what happens? Again, the bone we named “root” is animated in Blender, translating the character forward, while the Armature object “Character_Armature” has no animation. As we can see in the two images below, the bone “root” is translating forward, with the pink arrow indicating its final position. And the orange arrow points to the position of the Armature object, which was renamed to “Character_Armature”.

Watch what happens in Unreal. We don’t get the desired root motion in this case because the Armature object “Character_Armature” became the first bone in the skeleton hierarchy. What we now have is the second bone (the one we named “root”) translating the character. In other words, we don’t have the correct root motion in Unreal because the first bone in the skeleton hierarchy is not moving at all.

In the first GIF below, the bone “root” is selected and moving forward. In the second GIF, the bone Character_Armature” is selected and remains in place. To achieve proper root motion in Unreal, the “Character_Armature” bone would need to move forward instead of the “root” bone.

In this situation, where the Armature object is the first bone in the skeleton hierarchy in Unreal, the animator would need to switch to Object Mode in Blender and animate the Armature object to create proper root motion for the character. Keep in mind that the translation should be removed from the “root” bone in the Pose Mode; otherwise, both translations would be layered, resulting in twice the distance traveled.

So, let’s try one more time. In the image below, we removed the translation from the bone “root”. We then switched to Object Mode and we animated the Armature object “Character_Armature”. As we can see, the bone “root” follows the Armature object because it is a child of the Armature object, as we discussed earlier. The orange arrow indicates the final position of the Armature object “Character_Armature”. And the pink arrow shows the position of the bone “root”, which follows the Armature object because it is a child of the “Character_Armature”.

           When we export this animation to Unreal, the “Character_Armature” bone will translate forward, and we will see the root motion path when this bone is selected. This demonstrates that we can achieve root motion by animating the Armature object in Blender. The bone we named “root” will have no animation of its own and will simply follow the “Character_Armature”.

In the GIFs below, the “Character_Armature” and “root” bone are selected so we can observe their behavior in Unreal. In the second GIF, the root motion path (the red line) is not visible because the “Character_Armature” bone is not selected. The viewport mode in Unreal for the bones is set to only show the selected bones.

Be careful with one important detail: when you have different skeleton hierarchy structures in Unreal, each will be treated as a different character in the engine. For example, our Female Anti-Mage rig with the bone “root” as the first bone in the skeleton hierarchy will be one character in Unreal, while the same character rig with Character_Armature” as the first bone will be considered a different character. In short: different skeletons mean different characters. Watch out for that.

Both methods of working are valid. It is not wrong to have the Armature object as the first bone in the skeleton hierarchy in Unreal. It will still be treated as a bone once imported to Unreal. The challenge lies in the animator having to switch between Pose Mode and Object Mode in Blender every time they need to animate or adjust the root motion.

There is a caveat when the Armature object is the first bone in the skeleton hierarchy in Unreal. Since the Armature object in this setup acts as the first bone in the skeleton hierarchy and it is positioned at the world origin, we wouldn’t need another bone in that same location. Otherwise, in Unreal we would have two bones at the world origin, one parented to the other. Ideally, if we want the Armature object to serve as the first bone in the skeleton hierarchy in Unreal, we wouldn’t need to create he bone named “root” in Blender. We would only need to create the pelvis bone, which would then become a child of the Armature object bone in Unreal. However, the issue is that if we don’t create the bone “root” in Blender, the rig setup can become more complex, since the rig controls in Blender are the bones themselves. As a result, we wouldn’t have a simple setup with a master (or root) control in Pose Mode to move the pelvis and the limbs’ IK controls simultaneously. So, watch out for that.

Finally, one thing to pay attention to is when you have two or more rigs in the same Blender scene. By default, Blender will automatically rename the Armature object of the second rig if both rigs have the same Armature name. For example, if the first character rig has the Armature object named “Armature”, and you bring a second rig with the same Armature object name, Blender will rename it to “Armature.001”. Be mindful of this when exporting skeletal meshes and animations to Unreal. If you manually rename the second rig’s Armature object back to “Armature”, Blender will automatically rename the first rig’s Armature to “Armature.001”. Make sure to rename the Armature object of each rig when the time comes to export them or their animations.