599 lines
20 KiB
C#
599 lines
20 KiB
C#
using System;
|
||
using System.Collections.Generic;
|
||
using UnityEngine;
|
||
|
||
namespace XCharts.Runtime
|
||
{
|
||
public enum AnimationType
|
||
{
|
||
/// <summary>
|
||
/// he default. An animation playback mode will be selected according to the actual situation.
|
||
/// ||默认。内部会根据实际情况选择一种动画播放方式。
|
||
/// </summary>
|
||
Default,
|
||
/// <summary>
|
||
/// Play the animation from left to right.
|
||
/// ||从左往右播放动画。
|
||
/// </summary>
|
||
LeftToRight,
|
||
/// <summary>
|
||
/// Play the animation from bottom to top.
|
||
/// ||从下往上播放动画。
|
||
/// </summary>
|
||
BottomToTop,
|
||
/// <summary>
|
||
/// Play animations from the inside out.
|
||
/// ||由内到外播放动画。
|
||
/// </summary>
|
||
InsideOut,
|
||
/// <summary>
|
||
/// Play the animation along the path.
|
||
/// ||沿着路径播放动画。当折线图从左到右无序或有折返时，可以使用该模式。
|
||
/// </summary>
|
||
AlongPath,
|
||
/// <summary>
|
||
/// Play the animation clockwise.
|
||
/// ||顺时针播放动画。
|
||
/// </summary>
|
||
Clockwise,
|
||
}
|
||
|
||
public enum AnimationEasing
|
||
{
|
||
Linear,
|
||
}
|
||
|
||
/// <summary>
|
||
/// the animation of serie. support animation type: fadeIn, fadeOut, change, addition.
|
||
/// ||动画组件，用于控制图表的动画播放。支持配置五种动画表现：FadeIn（渐入动画），FadeOut（渐出动画），Change（变更动画），Addition（新增动画），Interaction（交互动画）。
|
||
/// 按作用的对象可以分为两类：SerieAnimation（系列动画）和DataAnimation（数据动画）。
|
||
/// </summary>
|
||
[System.Serializable]
|
||
public class AnimationStyle : ChildComponent
|
||
{
|
||
[SerializeField] private bool m_Enable = true;
|
||
[SerializeField] private AnimationType m_Type;
|
||
[SerializeField] private AnimationEasing m_Easting;
|
||
[SerializeField] private int m_Threshold = 2000;
|
||
[SerializeField][Since("v3.4.0")] private bool m_UnscaledTime;
|
||
[SerializeField][Since("v3.8.0")] private AnimationFadeIn m_FadeIn = new AnimationFadeIn();
|
||
[SerializeField][Since("v3.8.0")] private AnimationFadeOut m_FadeOut = new AnimationFadeOut() { reverse = true };
|
||
[SerializeField][Since("v3.8.0")] private AnimationChange m_Change = new AnimationChange() { duration = 500 };
|
||
[SerializeField][Since("v3.8.0")] private AnimationAddition m_Addition = new AnimationAddition() { duration = 500 };
|
||
[SerializeField][Since("v3.8.0")] private AnimationHiding m_Hiding = new AnimationHiding() { duration = 500 };
|
||
[SerializeField][Since("v3.8.0")] private AnimationInteraction m_Interaction = new AnimationInteraction() { duration = 250 };
|
||
|
||
[Obsolete("Use animation.fadeIn.delayFunction instead.", true)]
|
||
public AnimationDelayFunction fadeInDelayFunction;
|
||
[Obsolete("Use animation.fadeIn.durationFunction instead.", true)]
|
||
public AnimationDurationFunction fadeInDurationFunction;
|
||
[Obsolete("Use animation.fadeOut.delayFunction instead.", true)]
|
||
public AnimationDelayFunction fadeOutDelayFunction;
|
||
[Obsolete("Use animation.fadeOut.durationFunction instead.", true)]
|
||
public AnimationDurationFunction fadeOutDurationFunction;
|
||
[Obsolete("Use animation.fadeIn.OnAnimationEnd() instead.", true)]
|
||
public Action fadeInFinishCallback { get; set; }
|
||
[Obsolete("Use animation.fadeOut.OnAnimationEnd() instead.", true)]
|
||
public Action fadeOutFinishCallback { get; set; }
|
||
public AnimationStyleContext context = new AnimationStyleContext();
|
||
|
||
/// <summary>
|
||
/// Whether to enable animation.
|
||
/// ||是否开启动画效果。
|
||
/// </summary>
|
||
public bool enable { get { return m_Enable; } set { m_Enable = value; } }
|
||
/// <summary>
|
||
/// The type of animation.
|
||
/// ||动画类型。
|
||
/// </summary>
|
||
public AnimationType type
|
||
{
|
||
get { return m_Type; }
|
||
set
|
||
{
|
||
m_Type = value;
|
||
if (m_Type != AnimationType.Default)
|
||
{
|
||
context.type = m_Type;
|
||
}
|
||
}
|
||
}
|
||
/// <summary>
|
||
/// Whether to set graphic number threshold to animation. Animation will be disabled when graphic number is larger than threshold.
|
||
/// ||是否开启动画的阈值，当单个系列显示的图形数量大于这个阈值时会关闭动画。
|
||
/// </summary>
|
||
public int threshold { get { return m_Threshold; } set { m_Threshold = value; } }
|
||
/// <summary>
|
||
/// Animation updates independently of Time.timeScale.
|
||
/// ||动画是否受TimeScaled的影响。默认为 false 受TimeScaled的影响。
|
||
/// </summary>
|
||
public bool unscaledTime { get { return m_UnscaledTime; } set { m_UnscaledTime = value; } }
|
||
/// <summary>
|
||
/// Fade in animation configuration.
|
||
/// ||渐入动画配置。
|
||
/// </summary>
|
||
public AnimationFadeIn fadeIn { get { return m_FadeIn; } }
|
||
/// <summary>
|
||
/// Fade out animation configuration.
|
||
/// ||渐出动画配置。
|
||
/// </summary>
|
||
public AnimationFadeOut fadeOut { get { return m_FadeOut; } }
|
||
/// <summary>
|
||
/// Update data animation configuration.
|
||
/// ||数据变更动画配置。
|
||
/// </summary>
|
||
public AnimationChange change { get { return m_Change; } }
|
||
/// <summary>
|
||
/// Add data animation configuration.
|
||
/// ||数据新增动画配置。
|
||
/// </summary>
|
||
public AnimationAddition addition { get { return m_Addition; } }
|
||
/// <summary>
|
||
/// Data hiding animation configuration.
|
||
/// ||数据隐藏动画配置。
|
||
/// </summary>
|
||
public AnimationHiding hiding { get { return m_Hiding; } }
|
||
/// <summary>
|
||
/// Interaction animation configuration.
|
||
/// ||交互动画配置。
|
||
/// </summary>
|
||
public AnimationInteraction interaction { get { return m_Interaction; } }
|
||
|
||
private Vector3 m_LinePathLastPos;
|
||
private List<AnimationInfo> m_Animations;
|
||
private List<AnimationInfo> animations
|
||
{
|
||
get
|
||
{
|
||
if (m_Animations == null)
|
||
{
|
||
m_Animations = new List<AnimationInfo>();
|
||
m_Animations.Add(m_FadeIn);
|
||
m_Animations.Add(m_FadeOut);
|
||
m_Animations.Add(m_Change);
|
||
m_Animations.Add(m_Addition);
|
||
m_Animations.Add(m_Hiding);
|
||
}
|
||
return m_Animations;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// The actived animation.
|
||
/// ||当前激活的动画。
|
||
/// </summary>
|
||
public AnimationInfo activedAnimation
|
||
{
|
||
get
|
||
{
|
||
foreach (var anim in animations)
|
||
{
|
||
if (anim.context.start) return anim;
|
||
}
|
||
return null;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Start fadein animation.
|
||
/// ||开始渐入动画。
|
||
/// </summary>
|
||
public void FadeIn()
|
||
{
|
||
if (m_FadeOut.context.start) return;
|
||
m_FadeIn.Start();
|
||
}
|
||
|
||
/// <summary>
|
||
/// Restart the actived animation.
|
||
/// ||重启当前激活的动画。
|
||
/// </summary>
|
||
public void Restart()
|
||
{
|
||
var anim = activedAnimation;
|
||
Reset();
|
||
if (anim != null)
|
||
{
|
||
anim.Start();
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Start fadeout animation.
|
||
/// ||开始渐出动画。
|
||
/// </summary>
|
||
public void FadeOut()
|
||
{
|
||
m_FadeOut.Start();
|
||
}
|
||
|
||
/// <summary>
|
||
/// Start additon animation.
|
||
/// ||开始数据新增动画。
|
||
/// </summary>
|
||
public void Addition()
|
||
{
|
||
if (!enable) return;
|
||
if (!m_FadeIn.context.start && !m_FadeOut.context.start)
|
||
{
|
||
m_Addition.Start(false);
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Pause all animations.
|
||
/// ||暂停所有动画。
|
||
/// </summary>
|
||
public void Pause()
|
||
{
|
||
foreach (var anim in animations)
|
||
{
|
||
anim.Pause();
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Resume all animations.
|
||
/// ||恢复所有动画。
|
||
/// </summary>
|
||
public void Resume()
|
||
{
|
||
foreach (var anim in animations)
|
||
{
|
||
anim.Resume();
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Reset all animations.
|
||
/// </summary>
|
||
public void Reset()
|
||
{
|
||
foreach (var anim in animations)
|
||
{
|
||
anim.Reset();
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Initialize animation configuration.
|
||
/// ||初始化动画配置。
|
||
/// </summary>
|
||
/// <param name="curr">当前进度</param>
|
||
/// <param name="dest">目标进度</param>
|
||
public void InitProgress(float curr, float dest)
|
||
{
|
||
var anim = activedAnimation;
|
||
if (anim == null) return;
|
||
var isAddedAnim = anim is AnimationAddition;
|
||
if (IsSerieAnimation())
|
||
{
|
||
if (isAddedAnim)
|
||
{
|
||
anim.Init(anim.context.currPointIndex, dest, (int)dest - 1);
|
||
}
|
||
else
|
||
{
|
||
m_Addition.context.currPointIndex = (int)dest - 1;
|
||
anim.Init(curr, dest, (int)dest - 1);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
anim.Init(curr, dest, 0);
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Initialize animation configuration.
|
||
/// ||初始化动画配置。
|
||
/// </summary>
|
||
/// <param name="paths">路径坐标点列表</param>
|
||
/// <param name="isY">是Y轴还是X轴</param>
|
||
public void InitProgress(List<Vector3> paths, bool isY)
|
||
{
|
||
if (paths.Count < 1) return;
|
||
var anim = activedAnimation;
|
||
if (anim == null)
|
||
{
|
||
m_Addition.context.currPointIndex = paths.Count - 1;
|
||
return;
|
||
}
|
||
var isAddedAnim = anim is AnimationAddition;
|
||
var startIndex = 0;
|
||
if (isAddedAnim)
|
||
{
|
||
startIndex = anim.context.currPointIndex == paths.Count - 1 ?
|
||
paths.Count - 2 :
|
||
anim.context.currPointIndex;
|
||
if (startIndex < 0 || startIndex > paths.Count - 2) startIndex = 0;
|
||
}
|
||
else
|
||
{
|
||
m_Addition.context.currPointIndex = paths.Count - 1;
|
||
}
|
||
var sp = paths[startIndex];
|
||
var ep = paths[paths.Count - 1];
|
||
var currDetailProgress = isY ? sp.y : sp.x;
|
||
var totalDetailProgress = isY ? ep.y : ep.x;
|
||
if (context.type == AnimationType.AlongPath)
|
||
{
|
||
currDetailProgress = 0;
|
||
totalDetailProgress = 0;
|
||
var lp = sp;
|
||
for (int i = 1; i < paths.Count; i++)
|
||
{
|
||
var np = paths[i];
|
||
totalDetailProgress += Vector3.Distance(np, lp);
|
||
lp = np;
|
||
if (startIndex > 0 && i == startIndex)
|
||
currDetailProgress = totalDetailProgress;
|
||
}
|
||
m_LinePathLastPos = sp;
|
||
context.currentPathDistance = 0;
|
||
}
|
||
if (sp == anim.context.currPoint && ep == anim.context.destPoint)
|
||
{
|
||
return;
|
||
}
|
||
anim.context.currPoint = sp;
|
||
anim.context.destPoint = ep;
|
||
anim.Init(currDetailProgress, totalDetailProgress, paths.Count - 1);
|
||
}
|
||
|
||
public bool IsEnd()
|
||
{
|
||
foreach (var animation in animations)
|
||
{
|
||
if (animation.context.start)
|
||
return animation.context.end;
|
||
}
|
||
return m_FadeIn.context.end;
|
||
}
|
||
|
||
|
||
public bool IsFinish()
|
||
{
|
||
#if UNITY_EDITOR
|
||
if (!Application.isPlaying)
|
||
return true;
|
||
#endif
|
||
if (!m_Enable)
|
||
return true;
|
||
var animation = activedAnimation;
|
||
if (animation != null && animation.context.end)
|
||
return true;
|
||
if (IsSerieAnimation())
|
||
{
|
||
if (m_FadeOut.context.start) return m_FadeOut.context.currProgress <= m_FadeOut.context.destProgress;
|
||
else if (m_Addition.context.start) return m_Addition.context.currProgress >= m_Addition.context.destProgress;
|
||
else return m_FadeIn.context.currProgress >= m_FadeIn.context.destProgress;
|
||
}
|
||
else if (IsDataAnimation())
|
||
{
|
||
if (animation == null) return true;
|
||
else return animation.context.end;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
public bool IsInDelay()
|
||
{
|
||
var anim = activedAnimation;
|
||
if (anim != null)
|
||
return anim.IsInDelay();
|
||
return false;
|
||
}
|
||
|
||
/// <summary>
|
||
/// whther animaiton is data animation. BottomToTop and InsideOut are data animation.
|
||
/// ||是否为数据动画。BottomToTop和InsideOut类型的为数据动画。
|
||
/// </summary>
|
||
public bool IsDataAnimation()
|
||
{
|
||
return context.type == AnimationType.BottomToTop || context.type == AnimationType.InsideOut;
|
||
}
|
||
|
||
/// <summary>
|
||
/// whther animaiton is serie animation. LeftToRight, AlongPath and Clockwise are serie animation.
|
||
/// ||是否为系列动画。LeftToRight、AlongPath和Clockwise类型的为系列动画。
|
||
/// </summary>
|
||
public bool IsSerieAnimation()
|
||
{
|
||
return context.type == AnimationType.LeftToRight ||
|
||
context.type == AnimationType.AlongPath || context.type == AnimationType.Clockwise;
|
||
}
|
||
|
||
public bool CheckDetailBreak(float detail)
|
||
{
|
||
if (!IsSerieAnimation())
|
||
return false;
|
||
foreach (var animation in animations)
|
||
{
|
||
if (animation.context.start)
|
||
return !IsFinish() && detail > animation.context.currProgress;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
public bool CheckDetailBreak(Vector3 pos, bool isYAxis)
|
||
{
|
||
if (!IsSerieAnimation())
|
||
return false;
|
||
|
||
if (IsFinish())
|
||
return false;
|
||
|
||
if (context.type == AnimationType.AlongPath)
|
||
{
|
||
context.currentPathDistance += Vector3.Distance(pos, m_LinePathLastPos);
|
||
m_LinePathLastPos = pos;
|
||
return CheckDetailBreak(context.currentPathDistance);
|
||
}
|
||
else
|
||
{
|
||
if (isYAxis)
|
||
return pos.y > GetCurrDetail();
|
||
else
|
||
return pos.x > GetCurrDetail();
|
||
}
|
||
}
|
||
|
||
public void CheckProgress()
|
||
{
|
||
if (IsDataAnimation() && context.isAllItemAnimationEnd)
|
||
{
|
||
foreach (var animation in animations)
|
||
{
|
||
animation.End();
|
||
}
|
||
return;
|
||
}
|
||
foreach (var animation in animations)
|
||
{
|
||
animation.CheckProgress(animation.context.totalProgress, m_UnscaledTime);
|
||
}
|
||
}
|
||
|
||
public void CheckProgress(double total)
|
||
{
|
||
if (IsFinish())
|
||
return;
|
||
foreach (var animation in animations)
|
||
{
|
||
animation.CheckProgress(total, m_UnscaledTime);
|
||
}
|
||
}
|
||
|
||
internal float CheckItemProgress(int dataIndex, float destProgress, ref bool isEnd, float startProgress = 0)
|
||
{
|
||
isEnd = false;
|
||
var anim = activedAnimation;
|
||
if (anim == null)
|
||
{
|
||
isEnd = true;
|
||
return destProgress;
|
||
}
|
||
return anim.CheckItemProgress(dataIndex, destProgress, ref isEnd, startProgress, m_UnscaledTime);
|
||
}
|
||
|
||
public void CheckSymbol(float dest)
|
||
{
|
||
m_FadeIn.CheckSymbol(dest, m_UnscaledTime);
|
||
m_FadeOut.CheckSymbol(dest, m_UnscaledTime);
|
||
}
|
||
|
||
public float GetSysmbolSize(float dest)
|
||
{
|
||
#if UNITY_EDITOR
|
||
if (!Application.isPlaying)
|
||
return dest;
|
||
#endif
|
||
if (!enable)
|
||
return dest;
|
||
|
||
if (IsEnd())
|
||
return m_FadeOut.context.start ? 0 : dest;
|
||
|
||
return m_FadeOut.context.start ? m_FadeOut.context.sizeProgress : m_FadeIn.context.sizeProgress;
|
||
}
|
||
|
||
public float GetCurrDetail()
|
||
{
|
||
#if UNITY_EDITOR
|
||
if (!Application.isPlaying)
|
||
{
|
||
foreach (var animation in animations)
|
||
{
|
||
if (animation.context.start)
|
||
return animation.context.destProgress;
|
||
}
|
||
}
|
||
#endif
|
||
foreach (var animation in animations)
|
||
{
|
||
if (animation.context.start)
|
||
return animation.context.currProgress;
|
||
}
|
||
return m_FadeIn.context.currProgress;
|
||
}
|
||
|
||
public float GetCurrRate()
|
||
{
|
||
#if UNITY_EDITOR
|
||
if (!Application.isPlaying)
|
||
return 1;
|
||
#endif
|
||
if (!enable || IsEnd())
|
||
return 1;
|
||
return m_FadeOut.context.start ? m_FadeOut.context.currProgress : m_FadeIn.context.currProgress;
|
||
}
|
||
|
||
public int GetCurrIndex()
|
||
{
|
||
#if UNITY_EDITOR
|
||
if (!Application.isPlaying)
|
||
return -1;
|
||
#endif
|
||
if (!enable)
|
||
return -1;
|
||
var anim = activedAnimation;
|
||
if (anim == null)
|
||
return -1;
|
||
return (int)anim.context.currProgress;
|
||
}
|
||
|
||
public float GetChangeDuration()
|
||
{
|
||
if (m_Enable && m_Change.enable)
|
||
return m_Change.duration;
|
||
else
|
||
return 0;
|
||
}
|
||
|
||
public float GetAdditionDuration()
|
||
{
|
||
if (m_Enable && m_Addition.enable)
|
||
return m_Addition.duration;
|
||
else
|
||
return 0;
|
||
}
|
||
|
||
public float GetInteractionDuration()
|
||
{
|
||
if (m_Enable && m_Interaction.enable)
|
||
return m_Interaction.duration;
|
||
else
|
||
return 0;
|
||
}
|
||
|
||
public float GetInteractionRadius(float radius)
|
||
{
|
||
if (m_Enable && m_Interaction.enable)
|
||
return m_Interaction.GetRadius(radius);
|
||
else
|
||
return radius;
|
||
}
|
||
|
||
public bool HasFadeOut()
|
||
{
|
||
return enable && m_FadeOut.context.end;
|
||
}
|
||
|
||
public bool IsFadeIn()
|
||
{
|
||
return enable && m_FadeIn.context.start;
|
||
}
|
||
|
||
public bool IsFadeOut()
|
||
{
|
||
return enable && m_FadeOut.context.start;
|
||
}
|
||
|
||
public bool CanCheckInteract()
|
||
{
|
||
return enable && interaction.enable
|
||
&& !IsFadeIn() && !IsFadeOut();
|
||
}
|
||
}
|
||
} |