- animation layer

1 files changed, 94 insertions, 274 deletions

diff --git a/Erika/Assets/Scripts/Unit/Components/UnitAnimation/UnitAnimation.cs b/Erika/Assets/Scripts/Unit/Components/UnitAnimation/UnitAnimation.cs
index 593bd7b2..529cd2f5 100644
--- a/Erika/Assets/Scripts/Unit/Components/UnitAnimation/UnitAnimation.cs
+++ b/Erika/Assets/Scripts/Unit/Components/UnitAnimation/UnitAnimation.cs
@@ -4,269 +4,26 @@ using System.Collections;
 using System.Collections.Generic;
 using UnityEngine;
 #if UNITY_EDITOR
-using UnityEditor;
+using UnityEditor;

 #endif
-
-// http://unitylore.org/wiki/doku.php?id=l3y0gj

-
-// 单独一层动画
-public class AnimatorLayerInfo
-{
-    public int layer;
-
-    public int layerIndex { get { return (int)layer; } }
-
-    public string name { get { return m_Animator.GetLayerName(layerIndex); } }
-
-    public bool isBaseLayer { get { return layerIndex == 0; } }
-
-    private Animator m_Animator;
-
-    // 当前动作的animation data，如果是blendtree选第一个动作
-    private AnimationData m_AnimationData;
-    public AnimationData animationData
-    {
-        get
-        {
-            AnimatorClipInfo[] clipInfos = clipsInfo;
-            if (clipInfos == null || clipInfos.Length == 0)

-            {

-                LogHelper.LogError(LogTag.UnitAnimation, "No current animation.");

-                return null;
-            }
-            var clip = clipInfos[0]; //选第一个
-            string folder = m_UnitAnimation.owner.folder;
-            string name = clip.clip.name;
-            if (m_AnimationData != null && m_AnimationData.animationName == name)
-                return m_AnimationData;
-            string path = folder + "AnimationData/" + name + ".asset" ; // 要注意这里是用名字区别的，因为最终每个角色的动画都会在一个目录下面
-            m_AnimationData  = ResourceManager.Instance.LoadAsset<AnimationData>(path);
-            return m_AnimationData;
-        }
-    }
-
-	// 当前在播放的动作
-	// 如果处于transition中，认为当前状态是transition的目标状态（和Animator规则不一样）
-	public AnimatorStateInfo stateInfo
-    {
-        get
-        {
-			AnimatorStateInfo stateInfo = m_Animator.GetCurrentAnimatorStateInfo(layerIndex);
-			if (isInTransition) // 过渡中的动作认为当前动作是下一个动作
-			{
-				stateInfo = m_Animator.GetNextAnimatorStateInfo(layerIndex);
-			}
-			return stateInfo;
-		}
-    }
-
-    private int preStateHash = -1;
-
-    // 当前正在播放和融合的片段信息
-    public AnimatorClipInfo[] clipsInfo
-    {
-        get
-        {
-            AnimatorClipInfo[] clips = null;
-            if (!isInTransition) 

-            {

-                clips = m_Animator.GetCurrentAnimatorClipInfo(layerIndex);

-                if (clips.Length == 0)

-                {

-                    clips = m_Animator.GetNextAnimatorClipInfo(layerIndex);

-                }
-            }
-            else // 过渡中的动作认为当前动作是下一个动作

-            {

-                clips = m_Animator.GetNextAnimatorClipInfo(layerIndex);

-            }
-            return clips;
-        }
-    }
-
-	public AnimatorClipInfo clipInfo

-	{

-		get

-		{

-			return clipsInfo[0];

-		}

-	}
-
-    public int stateHash
-    {
-        get
-        {
-            return stateInfo.shortNameHash;
-        }
-    }
-
-    // 并非准确的播放时间，只是逻辑时间，因为动画会加速减速
-    public float playbackTimeInSeconds
-    {
-        get
-        {
-            return playbackNormalizedTime * clipInfo.clip.length; 
-        }
-    }
-
-    // 这个是真实世界的时间
-    private float m_PlaybackRealTime;
-    public float playbackRealTimeInSeconds
-    {
-        get
-        {
-            return m_PlaybackRealTime;
-        }
-    }
-
-    // 播放进度百分比，[0-1]，是逻辑上的，如果动画不是loop，那么播放完后normalizedTime是1
-    public float playbackNormalizedTime
-    {
-        get
-        {
-            AnimatorStateInfo state = stateInfo;
-            if (!state.loop && state.normalizedTime > 1)
-                return 1;
-            return state.normalizedTime % 1f;
-        }
-    }
-
-	public float playbackSpeed
-	{
-		get
-		{
-			return m_Animator.GetFloat("PlaybackSpeed" + layerIndex);
-		}
-		set
-		{
-			float v = Mathf.Clamp(value, 0, 10);
-			m_Animator.SetFloat("PlaybackSpeed" + layerIndex, v);
-		}
-	}
-
-	public float weight
-    {
-        get
-        {
-            return m_Animator.GetLayerWeight(layerIndex);
-        }
-    }
-
-    public int nextStateHash
-    {
-        get
-        {
-            AnimatorStateInfo nextState = m_Animator.GetNextAnimatorStateInfo(layerIndex);
-            int hash = nextState.shortNameHash; // 如果不在过渡中，hash是0
-            return hash;
-        }
-    }
-
-    public bool isInTransition
-    {
-        get
-        {
-            return m_Animator.IsInTransition(layerIndex);
-        }
-    }
-
-	public bool applySpeedCurve { get; set; }
-
-	UnitAnimation m_UnitAnimation;
-
-    Coroutine m_CalcPlaybackTimeCoroutine;
-
-	TimelineEventProxy m_TimelineEventProxy;
-
-	public string m_CurrentState;
-
-	public AnimatorLayerInfo(UnitAnimation unitAnimation, Animator animator, int layer)
-    {
-        this.m_UnitAnimation = unitAnimation;
-        this.m_Animator = animator;
-        this.layer = layer;
-		m_CalcPlaybackTimeCoroutine = unitAnimation.StartCoroutine(CalcPlaybackRealTimeCoroutine());
-		m_TimelineEventProxy = new TimelineEventProxy(unitAnimation.owner);
-		applySpeedCurve = true;
-	}
-
-	IEnumerator CalcPlaybackRealTimeCoroutine()
-    {
-        while (true)
-        {
-            if(preStateHash != stateHash)
-            {
-                m_PlaybackRealTime = 0;
-            }
-            m_PlaybackRealTime += Time.deltaTime;
-            preStateHash = stateHash;
-            yield return null; 
-        }
-    }
-
-    public bool IsToggleOpen(EAnimationToogle toggle)
-    {
-        if (m_AnimationData == null)
-            return false;
-        return m_AnimationData.IsToggleOpen(toggle, playbackNormalizedTime);
-    }
-
-	public void OnUpdate()
-	{
-        // 执行事件
-        m_TimelineEventProxy.ExecuteAnimationEvents(animationData, playbackTimeInSeconds * TimelineEventProxy.FPS);
-
-        // 播放速度控制
-        if (applySpeedCurve && animationData != null && animationData.speedCurve != null)
-		{
-			playbackSpeed = animationData.speedCurve.Evaluate(playbackNormalizedTime);
-		}
-	}
-
-	public void OnCrossFade(string animState, float normalizedTransitionDuration, float normalizedTimeOffset, float normalizedTransitionTime )
-	{
-		m_CurrentState = animState;

-		m_Animator.CrossFade(animState.ToString(), normalizedTransitionDuration, layerIndex, normalizedTimeOffset, normalizedTransitionTime);

-        m_TimelineEventProxy.ResetPrevAnimationData();

-

-        playbackSpeed = 1;

-    }

-

-    public void OnPlay(string animState, float normalizedTime)
-	{
-		m_CurrentState = animState;
-        m_Animator.Play(animState, layerIndex, normalizedTime);
-        m_TimelineEventProxy.ResetPrevAnimationData();

 

-        playbackSpeed = 1;

-    }
-}
-
+/// <summary>

+/// 角色动作管理

+/// http://unitylore.org/wiki/doku.php?id=l3y0gj 

+/// </summary>

 [DisallowMultipleComponent]
 public class UnitAnimation : UnitComponent
 {

 	// 角色的所有动作数据，包括（动画、事件、RM）

-	protected UnitActionData m_ActionData;
-
-    protected AnimatorLayerInfo[] layers { get { return m_LayerInfo; } }
-    protected AnimatorLayerInfo[] m_LayerInfo;
+	public UnitActionData m_ActionData;
+

+	// 当前动作，和AnimatorState不同，忽略过渡，即时切换

+	protected string m_CurrentAction = "Idle";
+	public string currentAction { get { return m_CurrentAction; } }
 
     public Animator animator { get { return m_Animator; } }
     protected Animator m_Animator;

 

-	protected virtual AnimatorLayerInfo baseLayer

-    {

-        get { return layers[0]; }

-    }

-

-	protected AnimatorLayerInfo layer
-    {
-        get

-        {

-            return baseLayer;

-        }
-    }
-
     public bool isInTransition
     {
         get
@@ -275,62 +32,115 @@ public class UnitAnimation : UnitComponent
         }
     }

 

+	// 当前动作的AnimationData

 	public AnimationData animationData

 	{

 		get

 		{

-			return layer.animationData;

+			return m_ActionData.GetAnimationData(currentAction);

 		}

 	}

 

-	public AnimatorClipInfo[] clipsInfo

+	// 当前动作的动画片段

+	public AnimationClip animationClip

 	{

 		get

 		{

-			return layer.clipsInfo;

+			if(animationData != null)

+			{

+				AnimationClip clip = ResourceManager.Instance.LoadAsset<AnimationClip>(animationData.animationPath);

+				return clip;

+			}

+			return null;

 		}

 	}

 

-	public AnimatorClipInfo clipInfo

+	public float playbackNormalizedTime

 	{

 		get

 		{

-			return layer.clipInfo;

+			AnimatorStateInfo state = stateInfo;

+			if (!state.loop && state.normalizedTime > 1)

+				return 1;

+			return state.normalizedTime % 1f;

 		}

 	}

 

-	public float playbackNormalizedTime

+	public AnimatorStateInfo stateInfo

 	{

 		get

 		{

-			return layer.playbackNormalizedTime;

+			AnimatorStateInfo stateInfo = m_Animator.GetCurrentAnimatorStateInfo(0);
+			if (isInTransition) // 过渡中的动作认为当前动作是下一个动作

+			{
+				stateInfo = m_Animator.GetNextAnimatorStateInfo(0);
+			}
+			return stateInfo;

 		}

 	}

 

-	public AnimatorStateInfo stateInfo

+	public int stateHash

 	{

 		get

 		{

-			return layer.stateInfo;

+			return stateInfo.shortNameHash;

 		}

 	}

 

-	public int stateHash

+	// 并非准确的播放时间，只是逻辑时间，因为动画会加速减速

+	public float playbackTimeInSeconds

 	{

 		get

 		{

-			return layer.stateHash;

+			return playbackNormalizedTime * animationClip.length;

 		}

 	}

 

+	TimelineEventProxy m_TimelineEventProxy;
+
+	public float playbackSpeed
+	{
+		get
+		{
+			return m_Animator.GetFloat("PlaybackSpeed" + 0);
+		}
+		set
+		{
+			float v = Mathf.Clamp(value, 0, 10);
+			m_Animator.SetFloat("PlaybackSpeed" + 0, v);
+		}
+	}
+
 	public override void OnUpdate()

     {

         base.OnUpdate();

-    }

+		// 执行事件

+		m_TimelineEventProxy.ExecuteAnimationEvents(animationData, playbackTimeInSeconds * TimelineEventProxy.FPS);

+

+		// 播放速度控制

+		if (/*applySpeedCurve && */animationData != null && animationData.speedCurve != null)
+		{
+			playbackSpeed = animationData.speedCurve.Evaluate(playbackNormalizedTime);
+		}

+	}

 

 	public bool IsToggleOpen(EAnimationToogle toggle)

 	{

-		return layer.IsToggleOpen(toggle);

+		return animationData.IsToggleOpen(toggle, playbackNormalizedTime);

+	}

+

+	public override void Initialize()

+	{

+		base.Initialize();

+

+	}

+

+	public override void OnPostInitialize()

+	{

+		base.OnPostInitialize();

+

+		m_TimelineEventProxy = new TimelineEventProxy(this.owner);
+		playbackSpeed = 1f;

 	}

 

 	/// <summary>

@@ -341,10 +151,15 @@ public class UnitAnimation : UnitComponent
 	/// <param name="normalizedTime"></param>

 	public void Play(string animState, int layerIndex = 0, float normalizedTime = float.NegativeInfinity)
     {

-        AnimatorLayerInfo layer = this.layers[layerIndex];

-        if (layer == null)

-            return;

-        layer.OnPlay(animState, normalizedTime);

+		//AnimatorLayerInfo layer = this.layers[layerIndex];

+		//if (layer == null)

+		//    return;

+		//layer.OnPlay(animState, normalizedTime);

+

+		m_CurrentAction = animState;

+

+		m_Animator.Play(animState, layerIndex, normalizedTime);

+		m_TimelineEventProxy.ResetPrevAnimationData();

 

 		UnitRootMotion rm = m_Owner.GetComponent<UnitRootMotion>();

 		if(rm)

@@ -363,10 +178,15 @@ public class UnitAnimation : UnitComponent
     /// <param name="normalizedTransitionTime"></param>

     public void CrossFade(string animState, float normalizedTransitionDuration, int layerIndex = 0, float normalizedTimeOffset = float.NegativeInfinity, float normalizedTransitionTime = 0.0f)

     {

-        AnimatorLayerInfo layer = this.layers[layerIndex];

-        if (layer == null)

-            return;

-        layer.OnCrossFade(animState, normalizedTransitionDuration, normalizedTimeOffset, normalizedTransitionTime);

+		//AnimatorLayerInfo layer = this.layers[layerIndex];

+		//if (layer == null)

+		//    return;

+		//layer.OnCrossFade(animState, normalizedTransitionDuration, normalizedTimeOffset, normalizedTransitionTime);

+

+		m_CurrentAction = animState;

+

+		m_Animator.CrossFade(animState.ToString(), normalizedTransitionDuration, layerIndex, normalizedTimeOffset, normalizedTransitionTime);

+		m_TimelineEventProxy.ResetPrevAnimationData();

 

 		UnitRootMotion rm = m_Owner.GetComponent<UnitRootMotion>();

 		if (rm)