Playable 动画系统
Playable 基本用法
Playable意思是可播放的，可运行的。Playable整体是树形结构，PlayableGraph相当于一个容器，所有元素都被包含在里面，图中的每个节点都是Playable，叶子节点的Playable包裹原始数据，相当于输入，中间的Mixer根据权重混合多个输入，最后汇总到根部的Output节点，然后由PlayableGraph播放。
Playable的核心类型
Playable的输出类型
这些不同类型的Playable都是结构体，所以它们之间不是继承关系，但是可以隐式转换，如
AnimationClipPlayable clipPlayable = AnimationClipPlayable.Create(playableGraph, clip);
//隐式转换
Playable playable = clipPlayable;
播放单个动画片段
官方示例
[RequireComponent(typeof(Animator))]
public class PlayAnimationSample : MonoBehaviour
{
public AnimationClip clip;
private PlayableGraph playableGraph;
void Start()
{
//创建PlayableGraph
playableGraph = PlayableGraph.Create();
playableGraph.SetTimeUpdateMode(DirectorUpdateMode.GameTime);
//创建AnimationClipPlayable包裹AnimationClip，附加到PlayableGraph上
var clipPlayable = AnimationClipPlayable.Create(playableGraph, clip);
//创建输出节点并把Animator设为目标，Animator会处理PlayableGraph
var playableOutput = AnimationPlayableOutput.Create(playableGraph, "Animation", GetComponent<Animator>());
//连接输入源
playableOutput.SetSourcePlayable(clipPlayable);
// Plays the Graph.
playableGraph.Play();
}
void OnDisable()
{
playableGraph.Destroy();
}
}
这样不使用Animator Controller，通过脚本就可以控制动画播放，而且Animator Controller是不允许运行时添加、删除动画的，使用Playable就可以运行时添加，删除动画。
使用PlayableGraph Visualizer查看Playable结构
创建动画混合树
[RequireComponent(typeof(Animator))]
public class MixAnimationSample : MonoBehaviour
{
public AnimationClip clip0;
public AnimationClip clip1;
public float weight;
private PlayableGraph playableGraph;
private AnimationMixerPlayable mixerPlayable;
private AnimationClipPlayable clipPlayable0;
void Start()
{
playableGraph = PlayableGraph.Create();
playableGraph.SetTimeUpdateMode(DirectorUpdateMode.GameTime);
var playableOutput = AnimationPlayableOutput.Create(playableGraph, "Animation", GetComponent<Animator>());
//创建AnimationMixerPlayable，2表示输入的数量
mixerPlayable = AnimationMixerPlayable.Create(playableGraph, 2);
playableOutput.SetSourcePlayable(mixerPlayable);
clipPlayable0 = AnimationClipPlayable.Create(playableGraph, clip0);
var clipPlayable1 = AnimationClipPlayable.Create(playableGraph, clip1);
//连接两个Playable，clipPlayable是源头，mixerPlayable是目标
//clipPlayable0和clipPlayable1的默认输出端口号是0，分别连接到mixerPlayable输入端口0和1
playableGraph.Connect(clipPlayable0, 0, mixerPlayable, 0);
playableGraph.Connect(clipPlayable1, 0, mixerPlayable, 1);
playableGraph.Play();
}
void Update()
{
//保证所有输入源的权重和为1
weight = Mathf.Clamp01(weight);
mixerPlayable.SetInputWeight(0, 1.0f-weight);
mixerPlayable.SetInputWeight(1, weight);
//切换输入的状态
if (Input.GetKeyDown(KeyCode.Space))
{
if (clipPlayable0.GetPlayState() == PlayState.Playing)
{
clipPlayable0.Pause();
}
else
{
clipPlayable0.Play();
clipPlayable0.SetTime(0f);
}
}
}
void OnDisable()
{
playableGraph.Destroy();
}
}
调整权重在两个动画之间过渡，我们还可以修改某个输入节点的状态
大型的RPG或FPS游戏，没必要把大量的动画都添加到Graph中，我们可以预先创建好需要的子树，然后根据需要在添加到Graph中
混合AnimationClip和AnimatorController
[RequireComponent(typeof(Animator))]
public class RuntimeControllerSample : MonoBehaviour
{
public AnimationClip clip;
public RuntimeAnimatorController controller;
public float weight;
private PlayableGraph playableGraph;
private AnimationMixerPlayable mixerPlayable;
void Start()
{
playableGraph = PlayableGraph.Create();
var playableOutput = AnimationPlayableOutput.Create(playableGraph, "Animation", GetComponent<Animator>());
mixerPlayable = AnimationMixerPlayable.Create(playableGraph, 2);
playableOutput.SetSourcePlayable(mixerPlayable);
var clipPlayable = AnimationClipPlayable.Create(playableGraph, clip);
var ctrlPlayable = AnimatorControllerPlayable.Create(playableGraph, controller);
playableGraph.Connect(clipPlayable, 0, mixerPlayable, 0);
playableGraph.Connect(ctrlPlayable, 0, mixerPlayable, 1);
playableGraph.Play();
}
void Update()
{
weight = Mathf.Clamp01(weight);
mixerPlayable.SetInputWeight(0, 1.0f-weight);
mixerPlayable.SetInputWeight(1, weight);
}
void OnDisable()
{
playableGraph.Destroy();
}
}
AnimationClipPlayable包裹AnimationClip，而AnimationrControllerPlayable则包裹RuntimeAnimationrController
每个角色都有的动画如走，跑，跳用Animator管理，角色的特殊动画用Playable和Animator融合
多个输出
[RequireComponent(typeof(Animator))]
[RequireComponent(typeof(AudioSource))]
public class MultiOutputSample : MonoBehaviour
{
public AnimationClip animationClip;
public AudioClip audioClip;
private PlayableGraph playableGraph;
void Start()
{
playableGraph = PlayableGraph.Create();
var animationOutput = AnimationPlayableOutput.Create(playableGraph, "Animation", GetComponent<Animator>());
var audioOutput = AudioPlayableOutput.Create(playableGraph, "Audio", GetComponent<AudioSource>());
var animationClipPlayable = AnimationClipPlayable.Create(playableGraph, animationClip);
var audioClipPlayable = AudioClipPlayable.Create(playableGraph, audioClip, true);
animationOutput.SetSourcePlayable(animationClipPlayable);
audioOutput.SetSourcePlayable(audioClipPlayable);
playableGraph.Play();
}
void OnDisable()
{
playableGraph.Destroy();
}
}
两个输出对象分别是Animator和AudioSource
自定义PlayableBehaviour实现动画队列
PlayableBehaviour 是一个用于实现自定义 Playable 的基类，它可以让开发者通过继承该类来自定义 Playable 行为，可以用于在播放过程中控制动画的逻辑
public class PlayQueuePlayable : PlayableBehaviour
{
private int m_CurrentClipIndex = -1;
private float m_TimeToNextClip;
private Playable mixer;
public void Initialize(AnimationClip[] clipsToPlay, Playable owner, PlayableGraph graph)
{
owner.SetInputCount(1);
mixer = AnimationMixerPlayable.Create(graph, clipsToPlay.Length);
graph.Connect(mixer, 0, owner, 0);
owner.SetInputWeight(0, 1);
for (int clipIndex = 0; clipIndex < mixer.GetInputCount(); ++clipIndex)
{
graph.Connect(AnimationClipPlayable.Create(graph, clipsToPlay[clipIndex]), 0, mixer, clipIndex);
mixer.SetInputWeight(clipIndex, 1.0f);
}
}
/// ScriptPlayable< T>.Create 是一个静态方法，用于创建一个ScriptPlayable< T>实例，并添加到PlayableGraph中。ScriptPlayable< T> 是一个结构体，用于创建自定义的 Playable 行为，其中T需要继承 PlayableBehaviour 。ScriptPlayable 结构体还提供了一些静态方法，用于创建和管理可播放对象。
ScriptPlayable< T>实例实际上是将泛型 T 包装在一个结构体中。这个结构体提供了一些方法，使得 T 类型能够被 PlayableGraph 所使用。
随机切换动画
实现从一个默认动画随机切换到另一个动画，这两个动画之间需要做融合，且播放完动画后切会默认动画，大致的流程如下
RandomSelector是一个随机选择器，Mixer是一个混合器，通过调整权重来实现切换
为了方便管理动画，把每个动画片段包裹到AnimUnit，管理动画状态，并输出信息
使用适配器实现多态，AnimAdapter里面有一个AnimBehaviour的引用，适配器本身没有功能，它的具体功能取决于引用AnimBehaviour的哪一个子类
/// /// /// public class AnimHelper
{
public static void Enable(Playable playable)
{
var adapter = GetAdapter(playable);
if (adapter != null)
{
adapter.Enable();
}
}
public static void Enable(AnimationMixerPlayable mixer, int index)
{
Enable(mixer.GetInput(index));
}
public static void Disable(Playable playable)
{
var adapter = GetAdapter(playable);
if (adapter != null)
{
adapter.Disable();
}
}
public static void Disable(AnimationMixerPlayable mixer, int index)
{
Disable(mixer.GetInput(index));
}
public static AnimAdapter GetAdapter(Playable playable)
{
//检查playbble类型是否继承AnimAdapter
if (typeof(AnimAdapter).IsAssignableFrom(playable.GetPlayableType()))
{
return ((ScriptPlayable<AnimAdapter>)playable).GetBehaviour();
}
return null;
}
public static void SetOutput(PlayableGraph graph, Animator animator, AnimBehaviour behaviour)
{
Root root = new Root(graph);
root.AddInput(behaviour);
var output = AnimationPlayableOutput.Create(graph, "Anim", animator);
output.SetSourcePlayable(root.GetAnimAdapterPlayable());
}
public static void Start(PlayableGraph graph, AnimBehaviour behaviour)
{
graph.Play();
behaviour.Enable();
}
public static void Start(PlayableGraph graph)
{
graph.Play();
//获取output的子节点，即root节点
GetAdapter(graph.GetOutputByType<AnimationPlayableOutput>(0).GetSourcePlayable()).Enable();
}
public static ComputeShader LoadCompute(string name)
{
ComputeShader computeShader = Resources.Load<ComputeShader>("Compute/" + name);
//拷贝一份实例，不然多个对象公用一个shader数据会冲突
return Object.Instantiate(computeShader);
}
}
AnimUnit 组件
/// 随机动画选择器组件 RandomSelector
/// /// 1D混合树组件 Mixer
简单的动画混合，根据切换的时间计算速度Speed，当前动画权重递减，目标动画权重递增
速度 * 时间 = 权重
速度 = 权重 / 时间
cur动画切换到tar（绿）动画，被tar（红）打断，此时如果cur的权重 > tar（绿）的权重，tar（绿）的权重要按照2倍的速度递减，tar（红）的权重 = 1 - cur权重 - tar（绿）权重
如果频繁打断动画，就可能有多个动画的权重需要递减到0，此时需要一个数组（del）保存被打断的动画
tar（黄）权重 = 1 - cur权重 - del数组内所有动画权重
切换打断时，如果cur（蓝）权重 < tar（绿）权重，就交换cur和tar
public class Mixer : AnimBehaviour
{
public int inputCount { get; private set; }
public int currentIndex => _currentIndex;
public bool IsTransition => _isTransition;
private AnimationMixerPlayable _mixerPlayable;
//当前动画索引
private int _currentIndex;
//目标动画索引
private int _targetIndex;
//递减列表
private List<int> _declineList;
private float _timeToNext;
//当前权重的递减速度
private float _currentSpeed;
//递减列表中权重的递减速度
private float _declineSpeed;
//是否在切换中
private bool _isTransition;
public Mixer(PlayableGraph graph) : base(graph)
{
_mixerPlayable = AnimationMixerPlayable.Create(graph, 0, true);
//连接到adapter上
_adapterPlayable.AddInput(_mixerPlayable, 0, 1);
_targetIndex = -1;
_declineList = new List<int>();
}
public override void AddInput(Playable playable)
{
base.AddInput(playable);
_mixerPlayable.AddInput(playable, 0, 0f);
inputCount++;
if(inputCount == 1)
{
_mixerPlayable.SetInputWeight(0, 1f);
_currentIndex = 0;
}
}
public override void Enable()
{
base.Enable();
if (inputCount > 0)
{
AnimHelper.Enable(_mixerPlayable, 0);
}
_adapterPlayable.SetTime(0);
_mixerPlayable.SetTime(0);
_adapterPlayable.Play();
_mixerPlayable.Play();
_mixerPlayable.SetInputWeight(0, 1f);
_currentIndex = 0;
_targetIndex = -1;
}
public override void Disable()
{
base.Disable();
_adapterPlayable.Pause();
_mixerPlayable.Pause();
for (int i = 0; i < inputCount; ++i)
{
_mixerPlayable.SetInputWeight(i, 0);
AnimHelper.Disable(_mixerPlayable, i);
}
}
public override void Execute(Playable playable, FrameData info)
{
base.Execute(playable, info);
if (!enable || !_isTransition || _targetIndex < 0)
return;
if (_timeToNext > 0f)
{
_timeToNext -= info.deltaTime;
//所有递减动画的权重之和
float declineWeight = 0;
for (int i = 0; i < _declineList.Count; ++i)
{
float w = ModifyWeight(_declineList[i], -info.deltaTime * _declineSpeed);
if (w <= 0f)
{
AnimHelper.Disable(_mixerPlayable, _declineList[i]);
_declineList.Remove(_declineList[i]);
}
else
{
declineWeight += w;
}
}
float curWeight = ModifyWeight(_currentIndex, -info.deltaTime * _currentSpeed);
SetWeight(_targetIndex, 1 - declineWeight - curWeight);
return;
}
//切换完成后
_isTransition = false;
AnimHelper.Disable(_mixerPlayable, _currentIndex);
_currentIndex = _targetIndex;
_targetIndex = -1;
}
/// 测试脚本
public class RandomSelectorExample : MonoBehaviour
{
public bool isTransition;
public float remainTime;
public AnimationClip[] clips;
private PlayableGraph _graph;
private Mixer _mixer;
private RandomSelector _randomSelector;
void Start()
{
_graph = PlayableGraph.Create();
var idle = new AnimUnit(_graph, clips[0], 0.5f);
_randomSelector = new RandomSelector(_graph);
for(int i = 1; i < clips.Length; i++)
{
_randomSelector.AddInput(clips[i], 0.5f);
}
_mixer = new Mixer(_graph);
_mixer.AddInput(idle);
_mixer.AddInput(_randomSelector);
_randomSelector.Select();
AnimHelper.SetOutput(_graph, GetComponent<Animator>(), _mixer);
AnimHelper.Start(_graph);
}
void Update()
{
if (Input.GetKeyDown(KeyCode.Space))
{
_randomSelector.Select();
_mixer.TransitionTo(1);
}
isTransition = _mixer.IsTransition;
remainTime = _randomSelector.remainTime;
if (!_mixer.IsTransition && _randomSelector.remainTime < 0.5f && _mixer.currentIndex != 0)
{
_mixer.TransitionTo(0);
}
}
void OnDestroy()
{
_graph.Destroy();
}
}
运行时按空格键随机选择一个动画播放，播放完切换到idle
2D混合树组件 BlendTree2D
使用 Compute Shader 把计算移到 GPU 上，在 Resources 目录下新建 Compute Shader “BlendTree2D”
// Each #kernel tells which function to compile; you can have many kernels
// 定义主函数名称
#pragma kernel Compute
struct DataPair
{
float x;
float y;
float weight;
};
float pointerX;
float pointerY;
//很小的数，防止除以0
float eps;
//定义结构化缓存
RWStructuredBuffer<DataPair> dataBuffer;
float mdistance(DataPair data)
{
return abs(pointerX - data.x) + abs(pointerY - data.y) + eps;
}
//声明XYZ三个维度线程组中的线程数量
[numthreads(16,1,1)]
void Compute (uint3 id : SV_DispatchThreadID)
{
dataBuffer[id.x].weight = 1 / mdistance(dataBuffer[id.x]);
}
[Serializable]
public struct BlendClip2D
{
public AnimationClip clip;
public Vector2 pos;
}
public class BlendTree2D : AnimBehaviour
{
private struct DataPair
{
public float x;
public float y;
public float weight;
}
private AnimationMixerPlayable _mixer;
private DataPair[] _dataPairs;
//把权重的计算移到GPU上
private ComputeShader _computeShader;
//传递数据
private ComputeBuffer _computeBuffer;
//shader中定义的计算主函数
private int _kernel;
private int _clipCount;
private Vector2 _lastPointer;
private int _pointerX;
private int _pointerY;
private float _total;
public BlendTree2D(PlayableGraph graph, BlendClip2D[] clips, float enterTime = 0f, float eps = 1e-5f) : base(graph, enterTime)
{
_mixer = AnimationMixerPlayable.Create(graph);
_dataPairs = new DataPair[clips.Length];
_adapterPlayable.AddInput(_mixer, 0, 1f);
for (int i = 0; i < clips.Length; i++)
{
var clip = clips[i].clip;
var clipPlayable = AnimationClipPlayable.Create(graph, clip);
_mixer.AddInput(clipPlayable, 0);
_dataPairs[i].x = clips[i].pos.x;
_dataPairs[i].y = clips[i].pos.y;
}
_computeShader = AnimHelper.LoadCompute("BlendTree2D");
//stride需要设置为4的倍数
_computeBuffer = new ComputeBuffer(_dataPairs.Length, 12);
_kernel = _computeShader.FindKernel("Compute");
_computeShader.SetBuffer(_kernel, "dataBuffer", _computeBuffer);
_computeShader.SetFloat("eps", eps);
_pointerX = Shader.PropertyToID("pointerX");
_pointerY = Shader.PropertyToID("pointerY");
_clipCount = clips.Length;
_lastPointer.Set(1, 1);
SetPointer(0,0);
}
public override void Enable()
{
base.Enable();
_adapterPlayable.SetTime(0);
_adapterPlayable.Play();
_mixer.SetTime(0);
_mixer.Play();
for (int i = 0; i < _clipCount; i++)
{
_mixer.GetInput(i).SetTime(0);
_mixer.GetInput(i).Play();
}
//初始化权重
SetPointer(0, 0);
}
public override void Disable()
{
base.Disable();
_adapterPlayable.Pause();
_mixer.Pause();
for (int i = 0; i < _clipCount; i++)
{
_mixer.GetInput(i).Pause();
}
}
public void SetPointer(Vector2 input)
{
SetPointer(input.x, input.y);
}
public void SetPointer(float x, float y)
{
if (_lastPointer.x == x && _lastPointer.y == y)
return;
_lastPointer.Set(x, y);
_computeShader.SetFloat(_pointerX, x);
_computeShader.SetFloat(_pointerY, y);
_computeBuffer.SetData(_dataPairs);
//运行计算着色器，以 X、Y 和 Z 维度中的指定计算着色器线程组启动
_computeShader.Dispatch(_kernel, _clipCount, 1, 1);
_computeBuffer.GetData(_dataPairs);
_total = 0;
int i;
for (i = 0; i < _clipCount; ++i)
{
_total += _dataPairs[i].weight;
}
for (i = 0; i < _clipCount; ++i)
{
_mixer.SetInputWeight(i, _dataPairs[i].weight / _total);
}
}
public override void Stop()
{
base.Stop();
_computeBuffer.Dispose();
}
}
测试脚本
public class BlendTree2DExample : MonoBehaviour
{
public Vector2 pointer;
public BlendClip2D[] clips;
private PlayableGraph _graph;
private BlendTree2D _blendTree2D;
void Start()
{
_graph = PlayableGraph.Create();
_blendTree2D = new BlendTree2D(_graph, clips);
AnimHelper.SetOutput(_graph, GetComponent<Animator>(), _blendTree2D);
AnimHelper.Start(_graph);
}
void Update()
{
_blendTree2D.SetPointer(pointer);
}
void OnDestroy()
{
_graph.Destroy();
}
}
运行时修改Pointer就会根据距离在动画片段之间做混合
参考
Playable 动画系统