扩展Unity的Timeline系统

　　最近有些地方要用到 Timeline 这样的系统, 因为 Unity 自己提供了一套, 就直接拿来用了, 发现这套 Timeline 设计的比较复杂, 而且很多点都缺失, 甚至生命周期都不完善, 有点为了解耦而强行 MVC / MVVM 的设计思路, 扩展起来还是很麻烦的.

　　简单来说要做扩展只要生成两份代码就行了, 一个是继承 PlayableAsset, ITimelineClipAsset 的 Clip, 可以把它看成是创建 Timeline 行为的入口, 它既是入口, 又是编辑器工具下的可视化对象, 另一个是继承 PlayableBehaviour 的, 它就是实际的 Timeline 逻辑对象, 包含了一些运行生命周期.

　　首先问题就是生命周期的问题, 它是一个积分类型的系统, 并且缺失了 OnComplete 的结束回调.

　　看看 PlayableBehaviour 的主要生命周期重载:

    public override void OnBehaviourPlay(Playable playable, FrameData info)
    {
        // 开始播放时触发
    }
    public override void ProcessFrame(Playable playable, FrameData info, object playerData)
    {
        // 播放后每帧触发
    }

　　如下图 OnBehaviourPlay 在系统运行到这个 Clip 的起点的时候, 会触发, 而如果系统运行到这个 Clip 还没结束的时候, 进行了暂停, 然后再次恢复播放的话, 它还是会触发 : 

　

　　举例来说一个UI按钮的点击, 在进入状态时触发点击, 退出状态时再次点击, 那么在这里首先是无法实现, 然后是点击的次数无法控制, 因为每次暂停都可能造成错误触发点击.

　　那么就需要扩展一套生命周期的控制, 来完成补充生命周期以及触发控制逻辑了. 直接通过继承 PlayableBehaviour 来创建一个基类扩展, 其它只要继承就行了 : 

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Playables;
using UnityEngine.Timeline;

namespace UnityTimelineExtention
{
    [System.Serializable]
    public abstract class PlayableBaseBehaviour : PlayableBehaviour
    {
        // 全局控制
        private static readonly Dictionary<PlayableDirector, HashSet<PlayableBaseBehaviour>> All = new Dictionary<PlayableDirector, HashSet<PlayableBaseBehaviour>>();

        // 通用数据
        [SerializeField]
        [Header("开始时间")]
        public double startTime = 0.0;
        [SerializeField]
        [Header("开始时间")]
        public double endTime = 0.0;

        // 缓存数据
        protected PlayableDirector playableDirector { get; private set; }

        // 属性
        public double duration { get { return endTime - startTime; } }
        protected bool Inited { get; set; }

        #region Main Funcs
        public override void OnBehaviourPlay(Playable playable, FrameData info)
        {
            base.OnBehaviourPlay(playable, info);
            if(false == Inited)
            {
                playableDirector = playable.GetGraph().GetResolver() as PlayableDirector;
                if(Application.isPlaying || CanPlayInEditorMode())
                {
                    All.GetValue(playableDirector).Add(this);
                    // 结束回调, 写在功能前
                    UnityTimelineEventDispatcher.Instance.SetEndCall(playableDirector, this, (_tag) =>
                    {
                        OnExit();
                    });
                    OnInit(playableDirector, info);
                }
            }
            Inited = true;
        }
        public override void ProcessFrame(Playable playable, FrameData info, object playerData)
        {
            base.ProcessFrame(playable, info, playerData);
            OnUpdate(playableDirector, info, playerData);
        }

        /// <summary>
        /// 只触发一次的接口
        /// </summary>
        /// <param name="playable"></param>
        /// <param name="info"></param>
        public abstract void OnInit(PlayableDirector playableDirector, FrameData info);

        /// <summary>
        /// 每个动画帧触发
        /// </summary>
        /// <param name="playableDirector"></param>
        /// <param name="info"></param>
        /// <param name="playerData"></param>
        public abstract void OnUpdate(PlayableDirector playableDirector, FrameData info, object playerData);

        /// <summary>
        /// 自动添加生命周期回调
        /// </summary>
        public abstract void OnExit();

        /// <summary>
        /// 标记, 是否能在编辑器下使用
        /// </summary>
        /// <returns></returns>
        public virtual bool CanPlayInEditorMode() { return true; }
        #endregion

        #region Help Funcs
        public void ResetInitState()
        {
            Inited = false;
        }

        /// <summary>
        /// 重置Init状态
        /// </summary>
        /// <param name="playableDirector"></param>
        public static void UnInit(PlayableDirector playableDirector)
        {
            var pool = All.TryGetNullableValue(playableDirector);
            if(pool != null)
            {
                foreach(var target in pool)
                {
                    target.ResetInitState();
                }
            }
        }

        /// <summary>
        /// 强制移除,重置Init状态 -- 小心使用
        /// </summary>
        /// <param name="playableDirector"></param>
        /// <param name="target"></param>
        public static void RemoveFromPool(PlayableDirector playableDirector, PlayableBaseBehaviour target)
        {
            var pool = All.TryGetNullableValue(playableDirector);
            if(pool != null)
            {
                if(pool.Remove(target))
                {
                    target.ResetInitState();
                }
            }
        }
        #endregion
    }
}

　　这样就添加了生命周期, 重命名成了 OnInit, OnUpdate, OnExit 这样的三个, 只有 OnExit 是额外添加的, 需要通过另外的监视器 UnityTimelineEventDispatcher 来实现 : 

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Playables;

namespace UnityTimelineExtention
{
    using Common;

    public class UnityTimelineEventDispatcher : Singleton<UnityTimelineEventDispatcher>
    {
        #region Defines
        public class PlayableEvent
        {
            public PlayableDirector playableDirector;
            public Common.ObsoluteTime timer;
            public double startTime;
            public double endTime;
            public double duration { get { return endTime - startTime; } }
            public System.Action endCall;

            public void Invoke()
            {
                if(endCall != null)
                {
                    var temp = endCall;
                    endCall = null;
                    temp.Invoke();
                }
            }
        }
        #endregion

        private bool _reigsted = false;

        private readonly Dictionary<PlayableDirector, MyDictionary<PlayableBaseBehaviour, PlayableEvent>> m_events
            = new Dictionary<PlayableDirector, MyDictionary<PlayableBaseBehaviour, PlayableEvent>>();
#region Overrides
        protected override void Initialize()
        {
            RegisterUpdate();
        }

        protected override void UnInitialize()
        {
            if(Application.isPlaying)
            {
                Core.CoroutineRoot.instance.update -= Tick;
            }
#if UNITY_EDITOR
            UnityEditor.EditorApplication.update -= Tick;
#endif
            _reigsted = false;
        }
        #endregion

        #region Main Funcs
        public void SetEndCall<T>(PlayableDirector director, T target, System.Action<T> endCall) where T : PlayableBaseBehaviour
        {
            if(director)
            {
                if(target != null)
                {
                    if(m_events.ContainsKey(director) == false)
                    {
                        director.stopped -= OnStop;
                        director.stopped += OnStop;
                    }
                    PopEnd(director, director.time);
                    var playableEvent = m_events.GetValue(director).GetValue(target);
                    playableEvent.playableDirector = director;
                    playableEvent.startTime = target.startTime;
                    playableEvent.endTime = target.endTime;
                    playableEvent.timer = new Common.ObsoluteTime();
                    playableEvent.endCall = () =>
                    {
                        endCall.Invoke(target);
                    };
                }
            }
        }

        private void Tick()
        {
            foreach(var kv in m_events)
            {
                kv.Value.Remove((_tag, _playableEvent) =>
                {
                    if(_playableEvent.playableDirector)
                    {
                        var gap = _playableEvent.playableDirector.time - (_playableEvent.startTime + _playableEvent.duration - 0.001);
                        if(gap >= 0.0)
                        {
                            _playableEvent.Invoke();
                            return true;
                        }
                    }
                    else
                    {
                        if(_playableEvent.timer.ElapsedSeconds() >= _playableEvent.duration)
                        {
                            _playableEvent.Invoke();
                            return true;
                        }
                    }

                    return false;
                });
            }
        }
        #endregion

        #region Help Funcs
        private void PopEnd(PlayableDirector director, double time)
        {
            var events = m_events.TryGetNullableValue(director);
            if(events != null)
            {
                events.Remove((_tag, _playableEvent) =>
                {
                    if(time >= (_playableEvent.startTime + _playableEvent.duration))
                    {
                        PlayableBaseBehaviour.RemoveFromPool(director, _tag);
                        _playableEvent.Invoke();
                        return true;
                    }
                    return false;
                });
            }
        }
        public void OnStop(PlayableDirector playableDirector)
        {
            if(playableDirector)
            {
                Debug.Log(playableDirector.gameObject.name + " Stopped");
                var events = m_events.TryGetNullableValue(playableDirector);
                if(events != null)
                {
                    PopEnd(playableDirector, playableDirector.duration + UnityTimelineTools.Epsilon);
                    events.Clear();
                }
            }
        }
        private void RegisterUpdate()
        {
            if(false == _reigsted)
            {
                _reigsted = true;
                if(Application.isPlaying)
                {
                    Core.CoroutineRoot.instance.update -= Tick;
                    Core.CoroutineRoot.instance.update += Tick;
                }
                else
                {
#if UNITY_EDITOR
                    UnityEditor.EditorApplication.update -= Tick;
                    UnityEditor.EditorApplication.update += Tick;
#endif
                }
            }
        }
        #endregion
    }
}

　　这里主要就是通过监视 PlayableDirector 的时间来测试一个 PlayableBehaviour 是否已经到达结束, 触发它的 OnExit 方法.

　　这里需要一提的是在运行时的 PlayableBehaviour 并没有自己的开始结束时间信息, 需要从 TimelineClip 里面去获取, 而 TimelineClip 又是从 PlayableAsset 的 TrackAsset 中找, 需要绕一个大圈, 非常麻烦, 而我们在重载接口里得到的输入一般是 Playable 或者 PlayableGraph, 要获取 PlayableBehaviour 也是需要显式转换 : 

playableDirector = playable.GetGraph().GetResolver() as PlayableDirector;

　　找资料都要找半天... 

　　通过这样的方式来找对应 TimelineClip : 

    // find clip
    public static TimelineClip FindClip(PlayableDirector director, PlayableAsset asset)
    {
        if(director)
        {
            var trackAssets = ((TimelineAsset)director.playableAsset).GetOutputTracks();
            foreach(var trackers in trackAssets)
            {
                foreach(var clip in trackers.GetClips())
                {
                    if(clip.asset == asset)
                    {
                        return clip;
                    }
                }
            }
        }
        return null;
    }
    // find clip
    public static TimelineClip FindClip(PlayableGraph graphy, PlayableAsset asset)
    {
        var director = graphy.GetResolver() as PlayableDirector;
        return FindClip(director, asset);
    }
    // find clip
    public static TimelineClip FindClip(Playable playable, PlayableAsset asset)
    {
        return FindClip(playable.GetGraph(), asset);
    }

　　有了这些, 我们现在需要的就是创建代码了, 做个工具生成代码就行了:

　　两个代码 template : 

　　1. Clip

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Playables;
using UnityEngine.Timeline;

namespace UnityTimelineExtention
{
    public class #CLASSNAME#Clip : PlayableAsset, ITimelineClipAsset
    {
        // 用来同步数据的
        public #CLASSNAME#Behaviour template;

        public ClipCaps clipCaps { get { return ClipCaps.None; } }
        // 重写初始化长度
        //public override double duration
        //{
        //    get { return 0.5f; }
        //}

        public override Playable CreatePlayable(PlayableGraph graph, GameObject owner)
        {
            var playable = ScriptPlayable<#CLASSNAME#Behaviour>.Create(graph, template);
            var playable#CLASSNAME#Behaviour = playable.GetBehaviour();
            var clip = UnityTimelineTools.FindClip(graph, this);
            if(clip != null)
            {
                playable#CLASSNAME#Behaviour.startTime = clip.start;
                 playable#CLASSNAME#Behaviour.endTime = clip.end;
            }
            return playable;
        }
    }
}

　　2. Behaviour

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Playables;
using UnityEngine.Timeline;

namespace UnityTimelineExtention
{
    [System.Serializable]
    public class #CLASSNAME#Behaviour : PlayableBaseBehaviour
    {
        // 基类数据
        /* playableDirector */

        // 当前动作开始回调
        public override void OnInit(PlayableDirector playableDirector, FrameData info)
        {
            // 功能
            Debug.Log("#CLASSNAME#Behaviour Play");
        }

        public override void OnUpdate(PlayableDirector playableDirector, FrameData info, object playerData)
        {
            // update
        }

        public override void OnExit()
        {
            // end
            Debug.Log("#CLASSNAME#Behaviour End");
        }
    }
}

　　这样生成的代码里面, XXXBehaviour 就有了生命周期了, 并且有了开始结束时间, 并且能限制 OnInit 在时间范围内只执行一次.

 　　这里有个特殊的对象, TimelineAsset 也就是在一个 TimelineAsset 里面嵌套另外一个, 编辑器本身没有支持, 所以它并不是一个完美嵌套的设计, 我这里就直接按照普通对象来生成代码然后添加强行播放逻辑:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Playables;
using UnityEngine.Timeline;

namespace UnityTimelineExtention
{
    [System.Serializable]
    public class TimelineAssetPlayerBehaviour : PlayableBaseBehaviour
    {
        // 面板序列化数据
        [SerializeField]
        public TimelineAsset timelineAsset;

        // 缓存数据
        private PlayableDirector assetDirector;
        private bool isPlaying = false;

        public override void OnInit(PlayableDirector playableDirector, FrameData info)
        {
            // 功能
            Debug.Log("TimelineAssetPlayerBehaviour Play");
            if(timelineAsset)
            {
                if(assetDirector == false)
                {
                    assetDirector = UnityTimelineTools.PlayTimeline(timelineAsset);
                }
                assetDirector.Pause();
                assetDirector.time = 0;
                assetDirector.Evaluate();
                isPlaying = true;
            }
        }

        public override void OnUpdate(PlayableDirector playableDirector, FrameData info, object playerData)
        {
            Tick((float)(playableDirector.time - this.startTime));
        }

        public override void OnExit()
        {
            isPlaying = false;
            if(assetDirector)
            {
                assetDirector.time = assetDirector.duration + UnityTimelineTools.Epsilon;
                assetDirector.Evaluate();
                assetDirector.Stop();
            }
        }

        private void Tick(float elapsedTime)
        {
            if(isPlaying && assetDirector)
            {
                assetDirector.time = elapsedTime;
                assetDirector.Evaluate();
            }
        }
    }
}

　　在播放过程中使用 Evaluate 的方式来进行, 保证逻辑一致, 并且在结束时调用 Stop 能正确触发结束回调.

　　所以可见, 一个 Behaviour 的开始结束时间信息非常重要.

------------------- 一些小技巧 -------------------

　　Unity系统的序列化支持泛型对象了, 比如下面的我需要拖入一个 Transform 来序列化这个 Transform 的绝对缩放可以这样写 : 

    [System.Serializable]
    public class SavableSelector<T, V> where T : Component where V : struct
    {
        [SerializeField]
        public V Value;

        private System.Func<T, V> _selector;

        public SavableSelector(System.Func<T, V> selector)
        {
            _selector = selector;
        }

        [Sirenix.OdinInspector.ShowInInspector]
        [Sirenix.OdinInspector.LabelText("拖入对象 --> ")]
        public T Target
        {
            get { return null; }
            set
            {
                if(value)
                {
                    this.Value = _selector.Invoke(value);
                }
            }
        }
    }

　　我在 XXXBehaviour 中这样来序列化 : 

    [SerializeField]
    [Header("记录原始缩放")]
    public SerializableDatas.SavableSelector<Transform, Vector3> Scaler = new SerializableDatas.SavableSelector<Transform, Vector3>((_trans) =>
    {
        return _trans.lossyScale;
    });

　　面板上可以得到这样的显示, 序列化数据就直接获取即可:

var rawScale = Scaler.Value;

　　依赖 OdinInspector 做一些编辑器的显示简直太方便了.