利用AnimatorStateInfo信息来处理当前的动画信息。
目前没出现什么bug，回调也相对精准。
使用方式：
("shoot", delegate() { });
("enable", true, delegate() { });
("shoot",delegate() { });源码：实现方式1
using ;
using UnityEngine;
namespace
{
/// <summary>
/// Animator 播放动画回调相关
/// </summary>
public class AnimatorPlayCall : MonoBehaviour
{
List<AnimatorPlayCallParam> Pools = new List<AnimatorPlayCallParam>();
static AnimatorPlayCall instance;
public static AnimatorPlayCall I
{
get
{
if (instance == null)
{
instance = new GameObject("AnimatorPlayCall").AddComponent<AnimatorPlayCall>();
(instance);
}
return instance;
}
}
/// <summary>
/// 检测Animator是否播放完毕
/// </summary>
/// <param name="animator"></param>
/// <param name="name"></param>
/// <param name="action"></param>
public void OnIsPlayOver(Animator animator,bool isCurrent, action)
{
if (action == null)
return;
(new AnimatorPlayCallParam(animator, isCurrent, action));
}
void Update()
{
if ( > 0)
{
for (int i = 0; i < ; i++)
{
if (Pools[i].Check())
{
(Pools[i]);
}
}
}
}
/// <summary>
/// 播放回调参数
/// </summary>
class AnimatorPlayCallParam
{
public AnimatorPlayCallParam(Animator animator, bool isCurrent, call)
{
Layer = 0;
Action = call;
Animator = animator;
IsCurrent = isCurrent;
}
public AnimatorPlayCallParam(Animator animator, bool isCurrent,int layer, call)
{
Layer = layer;
Action = call;
Animator = animator;
IsCurrent = isCurrent;
}
/// <summary>
/// 层
/// </summary>
public int Layer { private set; get; }
/// <summary>
/// 回调行为
/// </summary>
public Action { private set; get; }
/// <summary>
/// Animator 动画
/// </summary>
public Animator Animator { private set; get; }
/// <summary>
/// 是否当前动画
/// </summary>
public bool IsCurrent { private set; get; }
/// <summary>
/// 缓存的NameHash
/// </summary>
private int shortNameHash=0;
private AnimatorStateInfo CurInfo
{
get
{
return (Layer);
}
}
private AnimatorStateInfo NextInfo
{
get
{
return (Layer);
}
}
/// <summary>
/// 每帧检测动画状态
/// </summary>
/// <returns></returns>
public bool Check()
{
if (Action == null)
return true;
if(IsCurrent)
{
if(shortNameHash == 0 && != 0)
{
shortNameHash = ;
}
}
else
{
if (shortNameHash == 0 && != 0)
{
shortNameHash = ;
}
}
if ( != shortNameHash && shortNameHash != )
{
Action?.Invoke();
return true;
}
return false;
}
}
}
/// <summary>
/// Animator扩展
/// </summary>
public static class AnimatorExtension
{
public static void SetTrigger(this Animator animater, string name, action)
{
(name);
(animater,false, action);
}
public static void SetBool(this Animator animater, string name, bool value, action)
{
(name, value);
(animater, false, action);
}
public static void Play(this Animator animater, string name, action)
{
(name);
(animater, true, action);
}
public static void OnOver(this Animator animater,bool isCurrent, action)
{
(animater, isCurrent, action);
}
}
}源码：实现方式2【目前自己用的方式】
using ;
using UnityEngine;
namespace
{
/// <summary>
/// AnimatorOver完毕后回调管理
/// </summary>
public class AnimatorOverCallMgr
{
private AnimatorOverCallMgr() { }
private static AnimatorOverCallMgr instance;
public static AnimatorOverCallMgr I
{
get
{
if (instance == null)
{
instance = new AnimatorOverCallMgr();
}
return instance;
}
}
private Dictionary<string, AnimatorCallElement> callManager = new Dictionary<string, AnimatorCallElement>();
internal void HandleEvent(string name)
{
if ((name))
{
callManager[name].DoOver();
}
}
internal void RemoveHandleEvent(string name)
{
if ((name))
{
(name);
}
}
internal void AddListener(Animator animator, call)
{
string c_InstanceID = () + "";
if (!(c_InstanceID))
{
(c_InstanceID, new AnimatorCallElement(animator));
}
CheckEvent(animator, c_InstanceID);
callManager[c_InstanceID].onOver -= call;
callManager[c_InstanceID].onOver += call;
}
/// <summary>
/// 添加一个监听
/// </summary>
/// <param name="animator"></param>
/// <param name="call">返回值是(Layer,StateNameHash)</param>
public void AddListener(Animator animator, <int,int> call)
{
string c_InstanceID = () + "";
if (!(c_InstanceID))
{
(c_InstanceID, new AnimatorCallElement(animator));
}
CheckEvent(animator, c_InstanceID);
callManager[c_InstanceID].onOverByStateNameHash -= call;
callManager[c_InstanceID].onOverByStateNameHash += call;
}
/// <summary>
/// 移除一个监听
/// </summary>
/// <param name="animator"></param>
/// <param name="call"></param>
public void RemoveListener(Animator animator, <int,int> call)
{
string c_InstanceID = () + "";
if ((c_InstanceID))
{
callManager[c_InstanceID].onOverByStateNameHash -= call;
}
}
AnimationClip[] c_clips;
AnimationEvent[] c_events;
/// <summary>
/// 检查是否有Event
/// </summary>
/// <param name="animator"></param>
/// <param name="c_InstanceID"></param>
private void CheckEvent(Animator animator,string c_InstanceID)
{
if (<AnimatorOverCall>() == null)
{
AnimatorOverCall animatorOverCall = <AnimatorOverCall>();
(c_InstanceID);
c_clips = ;
for (int i = 0,length = c_clips.Length; i < length; i++)
{
if (c_clips[i] == null)
{
continue;
}
c_events = c_clips[i].events;
for (int j = 0; j < c_events.Length; j++)
{
if (c_events[j] == null)
{
continue;
}
if (c_events[j].functionName == "OverCall")
{
return;
}
}
c_clips[i].AddEvent(new AnimationEvent() { functionName = "OverCall", time = c_clips[i].length });
}
}
}
#region 内部类
private class AnimatorCallElement
{
public AnimatorCallElement(Animator animator)
{
= animator;
}
private Animator animator;
internal onOver;
internal event <int, int> onOverByStateNameHash;
internal void DoOver()
{
if (onOverByStateNameHash != null)
{
for (int i = 0, length = ; i < length; i++)
{
(i, (i).shortNameHash);
}
}
onOver?.Invoke();
onOver = null;
}
}
#endregion
}
/// <summary>
/// 对Animator扩展
/// </summary>
public static class AnimatorExtend
{
public static void Play(this Animator animator, string name, action,int layout=0)
{
if ((layout, (name)))
{
(name, layout);
(animator, action);
}
else
{
action?.Invoke();
("没有：" + name+"State");
}
}
/// <summary>
/// 添加完毕监听
/// </summary>
/// <param name="animater"></param>
/// <param name="action">返回值是(Layer,StateNameHash)</param>
public static void AddOverCall(this Animator animater, <int, int> action)
{
(animater, action);
}
/// <summary>
/// 移除完毕监听
/// </summary>
/// <param name="animater"></param>
/// <param name="action"></param>
public static void RemoveOverCall(this Animator animater, <int,int> action)
{
(animater, action);
}
}
[DisallowMultipleComponent]
internal class AnimatorOverCall : MonoBehaviour
{
private string instanceID;
internal void SetInstanceID(string id)
{
instanceID = id;
}
public void OverCall()
{
(instanceID);
}
private void OnDestroy()
{
(instanceID);
}
}
}
更复杂的可以考虑StateMachineBehaviour！