【AI&游戏】Unity Animancer动画系统

ChengHai37

947人浏览 · 2026-03-17 06:00:00

ChengHai37 · 2026-03-17 06:00:00 发布

【AI&游戏】专栏-直达

Unity Animancer 动画系统完全指南

一、引言

在现代游戏开发中，动画系统是构建生动角色和流畅游戏体验的关键组成部分。无论是角色移动、攻击释放，还是简单的待机呼吸，动画无时无刻不在塑造着玩家对游戏的感知。Unity自带的Mecanim动画系统虽然功能强大，但在处理复杂动画状态转换、层管理和混合时，往往需要编写大量代码，这让许多开发者感到困扰。Animancer的出现正是为了解决这一痛点，它提供了一套更加优雅、高效的动画管理方案。

Animancer是由Unity Asset Store上备受好评的动画系统插件，由专业开发者打造，旨在为Unity项目提供一种更加直观、灵活的动画控制方式。与传统的Animator Controller不同，Animancer采用代码驱动的动画管理方式，让开发者能够精确控制动画的播放、混合和状态切换。它不仅简化了动画系统的工作流程，还大幅提升了运行时性能，特别适合需要精细动画控制的游戏项目。

本文将全面深入地介绍Animancer的各个方面，从基础概念到高级应用，从技术原理到实战项目。我们将一起探索如何在Unity项目中有效地利用Animancer创建令人惊叹的动画效果，以及如何通过它来提升游戏角色的表现力。

二、动画系统基础理论

2.1 Unity动画系统概述

在深入了解Animancer之前，我们需要先理解Unity动画系统的基础知识。

Mecanim动画系统

Unity的Mecanim是默认的动画系统，它使用Animator Controller来管理动画状态机：

动画状态机：通过可视化界面管理不同动画状态之间的转换。
混合树：将多个动画进行混合，创造平滑的过渡效果。
动画层：允许同时播放多个动画，如身体动画和面部动画分离。
参数控制：通过脚本控制状态机的参数，如速度、触发器等。

传统Mecanim的局限性

尽管Mecanim功能强大，但在实际应用中存在一些问题：

状态机复杂：复杂角色可能需要数十个状态和转换，编辑变得困难。
运行时开销：状态机在每帧都需要评估转换条件。
代码控制受限：虽然可以通过代码控制参数，但不够直观。
调试困难：动画状态的切换对开发者来说不够透明。

2.2 Animancer的设计理念

Animancer采用了完全不同的方法来处理动画控制：

核心设计原则

代码驱动：通过代码直接控制动画的播放，而非依赖状态机。
显式控制：开发者清楚知道当前正在播放哪个动画。
按需加载：动画可以按需加载，不需要预先构建复杂的状态机。
高性能：简化了运行时的动画评估过程。

与Mecanim的对比

特性	Mecanim	Animancer
控制方式	状态机+参数	纯代码
学习曲线	较陡	较平缓
运行时开销	较高	较低
调试便利性	一般	优秀
复杂混合	需要混合树	直接控制

2.3 动画混合原理

理解动画混合原理对于有效使用Animancer至关重要：

线性混合

最基础的混合方式是线性插值：

// 两个动画之间的简单混合
float blend = 0.5f;
AnimationBlend = animationA * (1 - blend) + animationB * blend;

动画权重的层级传递

Animancer使用权重系统来控制每个动画层的影响力：

底层权重自动传递给上层
手动设置的权重会覆盖自动计算
权重总和通常保持为1

三、Animancer 核心组件

3.1 AnimancerComponent

AnimancerComponent是Animancer系统的核心组件，挂载在需要动画控制的角色上：

组件配置

// 获取Animancer组件
AnimancerComponent animancer = GetComponent<AnimancerComponent>();

// 组件关键属性
public class AnimancerComponent : MonoBehaviour
{
    public Animator animator;           // 底层Animator组件
    public LayerBinding[] layers;       // 动画层配置
    public float speed = 1f;           // 全局动画速度
    public bool playOnEnable = true;   // 启用时自动播放
}

初始化和使用

// 创建Animancer组件
AnimancerComponent animancer = gameObject.AddComponent<AnimancerComponent>();

// 播放动画
animancer.Play(attackAnimation);

// 获取当前状态
AnimancerState currentState = animancer.States.Current;

3.2 AnimancerState

AnimancerState代表一个动画状态，是所有动画操作的基础：

状态类型

Animancer支持多种状态类型：

ClipState：单个动画片段
MixerState：混合多个动画
LayerMixerState：层混合器
LinearMixerState：线性混合器
CircularMixerState：环形混合器

基本状态操作

// 创建ClipState
ClipState state = new ClipState(attackClip);

// 播放状态
animancer.Play(state);

// 获取或创建状态
ClipState idleState = animancer.States.GetOrCreate(idleClip);
ClipState runState = animancer.States.GetOrCreate(runClip);

// 设置权重
state.Weight = 1f;

// 监听动画结束
state.OnEnd += () => {
    Debug.Log("动画播放完成");
};

3.3 动画层系统

Animancer的层系统允许同时控制多个动画：

层的基本概念

// 创建新层
AnimancerLayer bodyLayer = animancer.Layers.GetOrCreate("Body");
AnimancerLayer upperBodyLayer = animancer.Layers.GetOrCreate("UpperBody");

// 设置层权重
bodyLayer.DefaultWeight = 1f;
upperBodyLayer.DefaultWeight = 0.5f;

// 在指定层播放动画
animancer.Play(upperBodyAnimation, 0, FadeMode.FixedSpeed);

层遮罩应用

// 创建动画层遮罩
AvatarMask mask = new AvatarMask();

// 添加需要包含的骨骼
mask.SetHumanoidBodyPartActive(AvatarBodyPart.LeftLeg, true);
mask.SetHumanoidBodyPartActive(AvatarBodyPart.RightLeg, true);

// 应用遮罩到层
bodyLayer.mask = mask;

3.4 动画事件系统

Animancer提供了强大的事件系统来处理动画回调：

事件类型

OnStart：动画开始播放时触发
OnEnd：动画播放完成时触发
OnInterrupt：动画被中断时触发
OnInterruptEnded：中断结束后触发

事件使用示例

// 订阅动画事件
ClipState attackState = animancer.Play(attackClip);

attackState.Events.OnStart += () => {
    Debug.Log("攻击动画开始");
    // 启用攻击判定
    EnableAttackHitbox();
};

attackState.Events.OnEnd += () => {
    Debug.Log("攻击动画结束");
    // 返回待机状态
    animancer.Play(idleClip);
};

attackState.Events.OnInterrupt += () => {
    Debug.Log("攻击被中断");
    // 禁用攻击判定
    DisableAttackHitbox();
};

四、解决的问题与应用场景

4.1 解决的问题

状态机复杂性

传统Mecanim状态机在处理复杂角色时面临挑战：

大量状态和转换导致编辑困难
转换条件难以调试
状态冲突难以排查

Animancer的解决方案

代码直接控制，无需复杂状态机
明确的动画状态追踪
简单的逻辑流程

性能开销问题

Mecanim状态机每帧都需要评估：

转换条件检查
混合树计算
层级权重传递

Animancer的优化

减少运行时计算
按需更新
更高效的混合实现

4.2 典型应用场景

动作游戏

动作游戏需要精细的动画控制：

连招系统：每个攻击动作需要精确控制
闪避动画：需要快速中断和转换
格挡系统：需要在正确时机播放防御动画

角色扮演游戏

RPG游戏中的角色动画管理：

多种武器类型切换
坐骑上下动画
交互动画（开门、拾取物品）

潜行游戏

潜行游戏需要无缝的动画过渡：

站蹲切换
墙壁攀爬
从隐藏处攻击

五、快速入门指南

5.1 安装与配置

获取Animancer

访问Unity Asset Store
搜索"Animancer"
购买并导入到项目

基本设置

在角色上添加Animator组件
添加AnimancerComponent组件
配置动画片段

5.2 播放第一个动画

基础动画播放

public class SimpleAnimation : MonoBehaviour
{
    public AnimancerComponent animancer;
    public AnimationClip idleClip;
    public AnimationClip walkClip;
    public AnimationClip runClip;
    
    void Start()
    {
        // 播放待机动画
        animancer.Play(idleClip);
    }
    
    void Update()
    {
        float horizontal = Input.GetAxis("Horizontal");
        float vertical = Input.GetAxis("Vertical");
        
        if (vertical > 0.1f)
        {
            // 根据速度选择动画
            if (Input.GetKey(KeyCode.LeftShift))
            {
                animancer.Play(runClip, 0.2f);
            }
            else
            {
                animancer.Play(walkClip, 0.2f);
            }
        }
        else
        {
            animancer.Play(idleClip, 0.2f);
        }
    }
}

5.3 动画过渡

平滑过渡

// 使用FadeMode进行平滑过渡
public enum FadeMode
{
    FixedSpeed,    // 固定速度
    FixedDuration, // 固定时间
    Hybrid         // 混合模式
}

// 0.2秒内从当前动画过渡到攻击动画
animancer.Play(attackClip, 0.2f, FadeMode.FixedDuration);

中断过渡

// 中断当前动画并播放新动画
animancer.Play(newAnimation);

// 检查是否正在播放特定动画
bool isAttacking = animancer.States.Current == attackState;

5.4 动画速度控制

基础速度控制

// 设置全局速度
animancer.Speed = 0.5f; // 半速播放

// 设置单个动画速度
animancer.Play(clip).Speed = 2f; // 2倍速播放

// 随时间变化的速度（模拟疲劳）
float currentSpeed = Mathf.Lerp(1f, 0.5f, fatigue);
animancer.States.Current.Speed = currentSpeed;

六、高级功能应用

6.1 动画混合器

Animancer提供了强大的混合器功能，用于创建复杂的动画过渡：

线性混合器

线性混合器在两个或多个动画之间进行线性插值：

// 创建线性混合器
LinearMixerState mixer = animancer.Layers[0].CreateState<LinearMixerState>();

// 添加动画到混合器
mixer.AddItem(idleClip);
mixer.AddItem(walkClip);
mixer.AddItem(runClip);

// 设置混合参数
mixer.Parameter = 0; // 初始值

void Update()
{
    // 根据玩家速度设置混合参数
    float speed = player.GetComponent<CharacterController>().velocity.magnitude;
    mixer.Parameter = Mathf.Clamp01(speed / maxSpeed);
}

2D混合树

// 创建2D混合器
StateMachine.Transition.Directional2D mixer = animancer.Layers[0].CreateState<Directional2D>();

// 添加方向动画
mixer.AddItem(forwardClip, new Vector2(0, 1));
mixer.AddItem(backwardClip, new Vector2(0, -1));
mixer.AddItem(leftClip, new Vector2(-1, 0));
mixer.AddItem(rightClip, new Vector2(1, 0));
mixer.AddItem(forwardLeftClip, new Vector2(-0.7f, 0.7f));

// 设置输入参数
void Update()
{
    float x = Input.GetAxis("Horizontal");
    float y = Input.GetAxis("Vertical");
    mixer.Parameter = new Vector2(x, y);
}

6.2 动画层高级应用

多重动画叠加

// 身体动画层
var bodyLayer = animancer.Layers.GetOrCreate("Body");
bodyLayer.AddState(idleState);
bodyLayer.AddState(walkState);

// 上半身动画层（叠加在身体动画上）
var upperBodyLayer = animancer.Layers.GetOrCreate("UpperBody");
upperBodyLayer.AddState(attackState);
upperBodyLayer.AddState(aimState);

// 设置权重
bodyLayer.SetWeight(1f);
upperBodyLayer.SetWeight(0f);

// 当攻击时淡入上半身动画
public void PlayAttack()
{
    upperBodyLayer.Play(attackState, 0.2f);
}

层权重动画

// 动态调整层权重
IEnumerator FadeInUpperBody()
{
    float duration = 0.3f;
    float timer = 0;
    
    while (timer < duration)
    {
        timer += Time.deltaTime;
        upperBodyLayer.Weight = timer / duration;
        yield return null;
    }
    
    upperBodyLayer.Weight = 1f;
}

6.3 动画事件进阶

自定义事件参数

// 创建带参数的事件
ClipState state = animancer.Play(clip);

state.Events.Add(new AnimancerEvent("OnDamage", 0.3f, (evt) => {
    // 在动画30%处触发
    DealDamage(evt.FloatParameter);
}));

// 设置事件参数
state.Events.SetFloatParameter("OnDamage", damageAmount);

事件回调系统

// 完整的事件系统
public class AnimationCallback : MonoBehaviour
{
    public AnimancerComponent animancer;
    
    void Start()
    {
        var state = animancer.Play(attackClip);
        
        // 注册多个回调
        state.OnStart = OnAnimationStart;
        state.OnEnd = OnAnimationEnd;
        state.OnInterrupt = OnAnimationInterrupt;
    }
    
    private void OnAnimationStart()
    {
        Debug.Log("动画开始");
        EnableHitbox();
    }
    
    private void OnAnimationEnd()
    {
        Debug.Log("动画结束");
        DisableHitbox();
        ReturnToIdle();
    }
    
    private void OnAnimationInterrupt()
    {
        Debug.Log("动画被中断");
        DisableHitbox();
    }
}

6.4 IK动画系统

IK集成

// 启用IK
void OnAnimatorIK(int layerIndex)
{
    if (animancer.Animator == null) return;
    
    // 设置IK权重
    animancer.Animator.SetIKPosition(AvatarIKGoal.LeftHand, leftHandTarget.position);
    animancer.Animator.SetIKRotation(AvatarIKGoal.LeftHand, leftHandTarget.rotation);
    animancer.Animator.SetIKPositionWeight(AvatarIKGoal.LeftHand, 1f);
    animancer.Animator.SetIKRotationWeight(AvatarIKGoal.LeftHand, 1f);
    
    // 设置LookAt
    animancer.Animator.SetLookAtPosition(lookAtTarget.position);
    animancer.Animator.SetLookAtWeight(1f, 0.5f, 0.8f, 0f);
}

七、与AI系统集成

7.1 行为树动画控制

将Animancer与行为树系统集成：

动画任务定义

[TaskCategory("Animation")]
[TaskDescription("播放指定动画")]
public class PlayAnimation : ActionTask
{
    public string animationName;
    public float fadeDuration = 0.2f;
    
    private AnimancerComponent animancer;
    private AnimancerState previousState;
    
    public override void OnStart()
    {
        animancer = gameObject.GetComponent<AnimancerComponent>();
    }
    
    public override TaskStatus OnUpdate()
    {
        AnimationClip clip = GetAnimationClip(animationName);
        if (clip == null)
            return TaskStatus.Failure;
        
        animancer.Play(clip, fadeDuration);
        return TaskStatus.Success;
    }
    
    private AnimationClip GetAnimationClip(string name)
    {
        // 从资源中加载或从缓存获取
        return Resources.Load<AnimationClip>(name);
    }
}

7.2 状态机集成

AI状态与动画同步

public class AIAnimationController : MonoBehaviour
{
    public AnimancerComponent animancer;
    public CharacterAI ai;
    
    private Dictionary<AIState, AnimationClip> stateAnimations;
    
    void Start()
    {
        stateAnimations = new Dictionary<AIState, AnimationClip>
        {
            { AIState.Idle, idleClip },
            { AIState.Patrol, walkClip },
            { AIState.Chase, runClip },
            { AIState.Attack, attackClip },
            { AIState.Hit, hitClip },
            { AIState.Death, deathClip }
        };
    }
    
    void Update()
    {
        AIState currentState = ai.CurrentState;
        
        if (stateAnimations.TryGetValue(currentState, out var clip))
        {
            animancer.Play(clip, 0.15f);
        }
    }
}

7.3 动画事件触发AI行为

// 动画事件触发AI响应
public class AnimationAIIntegration : MonoBehaviour
{
    public CharacterAI ai;
    public AnimancerComponent animancer;
    
    void Start()
    {
        // 攻击动画事件
        var attackState = animancer.Play(attackClip);
        
        // 在动画关键帧触发攻击
        attackState.Events.Add(new AnimancerEvent("OnAttackHit", 0.4f, (evt) => {
            ai.PerformAttack();
        }));
        
        // 动画结束返回AI状态
        attackState.Events.OnEnd += () => {
            ai.OnAnimationComplete();
        };
    }
}

八、性能优化与最佳实践

8.1 动画加载优化

按需加载

// 异步加载动画
IEnumerator LoadAnimationAsync(string path)
{
    ResourceRequest request = Resources.LoadAsync<AnimationClip>(path);
    
    while (!request.isDone)
    {
        yield return null;
    }
    
    AnimationClip clip = request.asset as AnimationClip;
    animancer.Play(clip);
}

// 预加载常用动画
public class AnimationPreloader : MonoBehaviour
{
    public string[] animationPaths;
    private Dictionary<string, AnimationClip> clipCache;
    
    void Start()
    {
        clipCache = new Dictionary<string, AnimationClip>();
        
        foreach (var path in animationPaths)
        {
            var clip = Resources.Load<AnimationClip>(path);
            if (clip != null)
            {
                clipCache[path] = clip;
            }
        }
    }
}

8.2 状态缓存

避免重复查找

public class OptimizedAnimation : MonoBehaviour
{
    private AnimancerComponent animancer;
    private ClipState idleState;
    private ClipState walkState;
    private ClipState runState;
    private ClipState attackState;
    
    void Start()
    {
        animancer = GetComponent<AnimancerComponent>();
        
        // 预先创建状态
        idleState = animancer.States.GetOrCreate(idleClip);
        walkState = animancer.States.GetOrCreate(walkClip);
        runState = animancer.States.GetOrCreate(runClip);
        attackState = animancer.States.GetOrCreate(attackClip);
    }
    
    void PlayWalk()
    {
        // 使用缓存的状态，避免查找开销
        animancer.Play(walkState, 0.2f);
    }
}

8.3 内存管理

对象池应用

// 动画状态对象池
public class AnimationStatePool
{
    private Stack<ClipState> pool = new Stack<ClipState>();
    
    public ClipState Get(AnimationClip clip)
    {
        ClipState state;
        
        if (pool.Count > 0)
        {
            state = pool.Pop();
            state.Clip = clip;
        }
        else
        {
            state = new ClipState(clip);
        }
        
        return state;
    }
    
    public void Return(ClipState state)
    {
        state.Weight = 0;
        pool.Push(state);
    }
}

8.4 最佳实践建议

代码组织

创建专门的动画管理器类
集中管理动画状态转换
使用常量定义动画名称

调试技巧

利用Animancer的调试视图
记录动画状态变化日志
可视化权重变化

性能建议

避免每帧创建新状态
合理使用混合器层级
及时释放不需要的动画

九、实战案例：完整角色动画系统

9.1 项目概述

创建一个完整的RPG角色动画系统，支持移动、攻击、防御、技能和交互等多种动画状态。

9.2 系统架构

动画系统组件

CharacterAnimationSystem
├── AnimancerComponent (核心组件)
├── AnimationLayers (动画层)
│   ├── BaseLayer (基础移动层)
│   ├── ActionLayer (动作层)
│   └── UpperBodyLayer (上半身层)
├── AnimationManager (动画管理器)
└── AnimationEvents (动画事件处理)

9.3 核心代码实现

角色动画管理器

public class CharacterAnimationManager : MonoBehaviour
{
    [Header("References")]
    public AnimancerComponent animancer;
    public CharacterController characterController;
    
    [Header("Base Animations")]
    public AnimationClip idleClip;
    public AnimationClip walkClip;
    public AnimationClip runClip;
    public AnimationClip jumpClip;
    
    [Header("Combat Animations")]
    public AnimationClip attackLightClip;
    public AnimationClip attackHeavyClip;
    public AnimationClip blockClip;
    public AnimationClip dodgeClip;
    public AnimationClip hitClip;
    public AnimationClip deathClip;
    
    [Header("State")]
    public float speed;
    public bool isAttacking;
    public bool isBlocking;
    
    // 缓存状态
    private ClipState idleState;
    private ClipState walkState;
    private ClipState runState;
    private ClipState attackState;
    private ClipState blockState;
    private ClipState dodgeState;
    private ClipState hitState;
    private ClipState deathState;
    
    void Start()
    {
        // 初始化状态缓存
        idleState = animancer.States.GetOrCreate(idleClip);
        walkState = animancer.States.GetOrCreate(walkClip);
        runState = animancer.States.GetOrCreate(runClip);
        attackState = animancer.States.GetOrCreate(attackLightClip);
        blockState = animancer.States.GetOrCreate(blockClip);
        dodgeState = animancer.States.GetOrCreate(dodgeClip);
        hitState = animancer.States.GetOrCreate(hitClip);
        deathState = animancer.States.GetOrCreate(deathClip);
        
        // 播放待机动画
        animancer.Play(idleState);
        
        // 注册动画事件
        RegisterAnimationEvents();
    }
    
    void Update()
    {
        if (IsDead()) return;
        
        if (isAttacking || IsInvoking("EndAttack"))
        {
            return; // 攻击中不响应移动
        }
        
        // 处理移动动画
        UpdateMovementAnimation();
        
        // 处理输入
        HandleInput();
    }
    
    void UpdateMovementAnimation()
    {
        if (isBlocking)
        {
            return;
        }
        
        speed = characterController.velocity.magnitude;
        
        if (speed < 0.1f)
        {
            animancer.Play(idleState, 0.2f);
        }
        else if (speed < 5f)
        {
            animancer.Play(walkState, 0.2f);
        }
        else
        {
            animancer.Play(runState, 0.2f);
        }
    }
    
    void HandleInput()
    {
        // 攻击输入
        if (Input.GetMouseButtonDown(0) && !isAttacking)
        {
            PerformAttack();
        }
        
        // 防御输入
        if (Input.GetMouseButton(1))
        {
            StartBlock();
        }
        else if (Input.GetMouseButtonUp(1))
        {
            EndBlock();
        }
        
        // 闪避输入
        if (Input.GetKeyDown(KeyCode.Space))
        {
            PerformDodge();
        }
    }
    
    void PerformAttack()
    {
        isAttacking = true;
        
        // 根据输入选择攻击类型
        AnimationClip attackClip = Input.GetKey(KeyCode.LeftShift) ? 
            attackHeavyClip : attackLightClip;
        
        var state = animancer.Play(attackClip, 0.1f);
        
        // 动画结束后重置状态
        state.OnEnd += () => {
            isAttacking = false;
            animancer.Play(idleState, 0.2f);
        };
    }
    
    void StartBlock()
    {
        isBlocking = true;
        animancer.Play(blockState, 0.1f);
    }
    
    void EndBlock()
    {
        isBlocking = false;
        animancer.Play(idleState, 0.2f);
    }
    
    void PerformDodge()
    {
        var state = animancer.Play(dodgeState, 0.1f);
        
        state.OnEnd += () => {
            animancer.Play(idleState, 0.2f);
        };
    }
    
    public void PlayHitAnimation()
    {
        var state = animancer.Play(hitState, 0.05f);
        
        state.OnEnd += () => {
            animancer.Play(idleState, 0.2f);
        };
    }
    
    public void PlayDeathAnimation()
    {
        animancer.Play(deathState, 0.2f);
    }
    
    bool IsDead()
    {
        // 检查角色是否死亡
        return false; // 简化实现
    }
    
    void RegisterAnimationEvents()
    {
        // 为攻击动画添加命中事件
        attackState.Events.Add(new AnimancerEvent("OnAttackHit", 0.5f, (evt) => {
            // 触发命中检测
            CheckAttackHit();
        }));
    }
    
    void CheckAttackHit()
    {
        // 实现命中检测逻辑
    }
}

上半身动画系统

public class UpperBodyAnimation : MonoBehaviour
{
    public AnimancerComponent animancer;
    public AnimancerLayer upperBodyLayer;
    
    public AnimationClip aimClip;
    public AnimationClip shootClip;
    public AnimationClip reloadClip;
    
    void Start()
    {
        // 创建上半身层
        upperBodyLayer = animancer.Layers.GetOrCreate("UpperBody");
        upperBodyLayer.SetMask(CreateUpperBodyMask());
        upperBodyLayer.SetWeight(0);
    }
    
    public void PlayAim()
    {
        upperBodyLayer.Play(aimClip, 0.2f);
    }
    
    public void PlayShoot()
    {
        var state = upperBodyLayer.Play(shootClip, 0.1f);
        
        state.OnEnd += () => {
            upperBodyLayer.Play(aimClip, 0.2f);
        };
    }
    
    public void PlayReload()
    {
        upperBodyLayer.Play(reloadClip, 0.2f);
    }
    
    AvatarMask CreateUpperBodyMask()
    {
        AvatarMask mask = new AvatarMask();
        
        // 设置只包含上半身
        mask.AddTransformPath(AvatarMaskBodyBones.Spine);
        mask.AddTransformPath(AvatarMaskBodyBones.Chest);
        mask.AddTransformPath(AvatarMaskBodyBones.Head);
        mask.AddTransformPath(AvatarMaskBodyBones.LeftArm);
        mask.AddTransformPath(AvatarMaskBodyBones.LeftHand);
        mask.AddTransformPath(AvatarMaskBodyBones.RightArm);
        mask.AddTransformPath(AvatarMaskBodyBones.RightHand);
        
        return mask;
    }
}