2.1 The Animation window: features and settings

2.2 Editing Animation Clips

2.3 Model-specific animation import settings

2.4 Cutting imported Animation Clips

2.5 Setting the Root Motion of imported Animation Clips

2.6 Finishing an Animation Clip: additional settings

2.7 Creating and configuring Animation Events

2.8 Configuring Generic Rigs

2.9 Configuring Humanoid Rigs

In this learning project, you'll explore how to work with Assets as you create animations using the Unity Animation systems.

Working with Assets

1.1 Welcome to the course

1.2 Core concepts: animation data

1.3 Core concepts: animation blending

3.1 Introduction to the Animator component

3.2 Introduction to animation blending

3.3 Creating and configuring Animator States

3.4 Creating and configuring Blend Trees

3.5 Creating and configuring Transitions

3.6 Creating a State Machine

3.7 Creating and configuring Animator Layers

4.1 Introduction to general animation scripting

4.2 Introduction to Humanoid-specific animation scripting

Introduction to 3D Animation Systems Assets

Review the core concepts underlying Unity's 3D animation systems, and explore practical examples provided in the course Unity project.

Course overview and core concepts

In this learning project, you'll get to know the Animator as you explore animation blending, State Machines and Animation Layers. 

By the end of the project, you'll have completed a comprehensive overview of Unity's 3D Animation Systems

The Animator

In this final learning project, you'll review the basics of general and Humanoid-specific animation scripting.

Introduction to animation scripting

In this course, you'll explore the fundamentals of Unity’s 3D animation systems. You will:

Review the core concepts for the animation systems in Unity

Connect those core concepts to the functionality of the Unity Editor

Apply your learning through creating and modifying simple animations

Review key principles of scripting for animation


By the end of this course, you'll be able to:

Confidently use Unity's 3D animation systems to create basic in-game (or in-app) animations for your own projects

Begin to create custom animation scripts, if you have relevant C# scripting experience for Unity.


This course is for intermediate and confident beginner users of Unity. It will help you develop your understanding of the animation systems in Unity, but will be of limited use to learners who want to create cinematic animations for media experiences or game cutscenes. 

To get the most out of the course, you’ll need basic coding experience in Unity. This will help inform your understanding of the complexity of different animations scripting scenarios.

Introduction to 3D Animation Systems

c5c8f004-e09c-54d9-8909-9a82e4dd2349:zx7pohSEomVRos4yXEncJx

Overview

Before you begin

The fundamentals of model animation

Importing constraints and animations

Baking animations

Resampling Animation Curves

Optimizing the animation size

Configuring custom properties

Summary

Explore the basics of model-specific animation 

Review a range of animation import settings 

When you’ve finished, you’ll be ready to cut an imported Animation Clip.

In this tutorial, you’ll learn about the basics of model-specific animation and review a range of animation import settings. 

When models are imported from digital content creation (DCC) programs, they have animation settings that are split into two sections: 

Model-specific settings, which affect all animations imported with that model.

Animation-specific settings, which affect individual animations imported with that model.

You can find all the settings reviewed in this tutorial in the Animation tab in the Inspector when a model is selected. 

The model called HumanoidIdle is selected. The Inspector has Model, Rig, Animation and Materials tabs, of which the Animation tab is selected. A number of settings are shown below.

This tutorial uses the Introduction to 3D Animation Systems Unity project. If you haven't already done so, download this before continuing.

2.  In the Project window, go to Assets > 2.3 Model specific animation import settings.

You’ll be able to review the settings in the Animation tab in the Inspector. 

Models in Unity are represented by a Mesh of triangles. When you want to animate a model, the Mesh must be deformed so that its triangles change position and shape. 

Models can contain too many triangles for each of them to be moved individually. The higher the definition of a model, the greater the number of triangles. Instead of moving each triangle individually during animation, models are skinned before they are animated.

Skinning gives each of the vertices making up the triangles a dependence on a ‘bone’. This bone is then moved using animation data and the associated vertices work out where they should be based on the bone’s position and rotation.

Bone hierarchies and the way they affect meshes are part of Rigs. For more information about Rigs, review 2.8 Configuring Generic Rigs.

In Unity, bones are represented by Transforms. You’ll learn about two types of Transforms in this tutorial:

Transforms have a hierarchical structure. This means that child Transforms move relative to their parents. The same is true of bones. 

For example, a hand bone’s position would depend on a lower arm bone’s position. That, in turn, would depend on an upper arm bone’s position, and so on. 

This dependency is known as forward kinematics (FK), and is commonly used for animation as you can set the position and rotation properties as you wish, in order to get the desired overall animation. 

Another technique for animation is called inverse kinematics (IK). This is where the end of a chain of bones has its position or rotation set, and then the positions and rotations of bones further up the chain are set via an algorithm to accommodate the end bone’s position and rotation.

Inverse kinematics can be used to author animations in DCC software, which can then be imported into Unity. It can also be used for runtime animation in Unity.

Understanding these fundamentals will help you understand the different settings available when you import model animations into Unity.

The first two settings in the Animation tab are:

These settings determine whether constraints and animations associated with the model should be imported or not.


Constraints are limits on the motion of joints. If you choose to import them, they can be part of instantiated models. If you choose not to import animations, there will be no more settings to configure and no Animation Clips will be generated. 

The Inspector window has the Animation tab selected. The top most settings are shown and Import Constraints is highlighted.

The next setting in the Animation tab is Bake Animations. This determines whether animations imported as inverse kinematics (IK) or simulation data should be converted into forward kinematics (FK) through a process called baking. 

Animation Clips store their data in an FK format, which means that models that are imported with IK data should be baked to convert the data from IK to FK.

You can enable the Bake Animations setting if two criteria are met:

The imported animation was created in either Maya, 3DS Max or Cinema 4D.

The animation is imported as IK or simulation data.

The next setting is Resample Curves. This option is only available for models with generic rigs, as humanoid rigs are automatically resampled. 

This setting determines whether animations imported with euler angles for their rotations should have these converted to quaternion angles instead.



As a general rule, you should resample all animations that are imported with euler angles. The only exception is if you’re having trouble with the conversion, for example if an animation makes a rotation greater than 180 degrees between frames.  

The Inspector window has the Animation tab selected. The top settings are shown.

The Animation Compression setting refers to how the animation’s size, both on disk and in memory, can be reduced by making approximations from the original imported file. You can select from the following options:

Off: Displays the animation exactly as it was created with no approximations.

Keyframe Reduction: Some Keyframes with similar values will be removed to reduce the amount of memory the Animation Clip takes up at runtime. This will also affect the resulting animation. If you select this setting, you’ll get additional options for the amount of error allowed in the reduction.

Optimal: This will make the animation size as small as possible given the chosen settings for error. 

If you choose the Optimal setting, Unity will first attempt to use Keyframe Reduction. If there is a high frequency of changes in Animation Curve values, then Keyframe Reduction won’t reduce the size by much. 

In this case, a simplified representation of the Animation Clip is used with linear interpolation between the value at each frame. This will result in the smallest Animation Clip size and will affect the appearance of the animation. 


When deciding whether or not to remove a Keyframe as part of the Keyframe Reduction setting, Unity assesses the position and scale values at the time of a particular Keyframe. It does this to find out whether the removal of the Keyframe will impact the Animation Curve within a particular margin of error. If the Keyframe is outside of the margin of error, it will not be removed.

The default margin of error is 0.5%. This means that the evaluation of the position and scale values at the Keyframe’s time must be between 100.5% and 99.5% of the surrounding Keyframe values for it to be removed by the compression process.

If there are very large values for positions and scales, Keyframes are more likely to be removed.

The process is similar for rotation curves using the Rotation Error, but instead a quaternion is evaluated.

The Inspector window has the Animation tab selected. The top most settings are shown. The Animation Compression property is highlighted and the dropdown is opened showing the Off, Keyframe Reduction and Optimal options.

The final general setting is Animated Custom Properties. This is an advanced setting for importing additional properties that were animated in the DCC package used to create the model. 

The fundamentals of model animation, including skinning.

The two different types of Transform used for model animation: forward kinematics (FK) and inverse kinematics (IK).

The model-specific settings required to import animations from digital content creation (DCC) software into Unity.

In the next tutorial, you’ll explore the animation-specific settings used to cut an imported Animation Clip.

2.3 Model-specific animation import settings

1. Overview

2. Before you begin

3. The fundamentals of model animation

4. Importing constraints and animations

5. Baking animations

6. Resampling Animation Curves

7. Optimizing the animation size

8. Configuring custom properties

9. Summary

Complete this tutorial