garden_client/Assets/Script/Tool/Anim/TweenRenderer.cs

using UnityEngine;

using System.Linq;
using System.Collections;
using System.Collections.Generic;

public class TweenRenderer : TweenRoot
{
    #region 变量

    public override bool InOrigin
    {
        get
        {
            if (Target.material.GetColor("_Color").Equal(Origin))
            {
                InOrigin_ = true;
            }
            else
            {
                InOrigin_ = false;
            }

            return InOrigin_;
        }
        set
        {
            InOrigin_ = value;

            InPause = false;
            InForward = false;
            InBackward = false;

            if (InOrigin_)
            {
                Target.material.SetColor("_Color", Origin);

                if (Group)
                {
                    for (int i = 0; i < ChildList.Count; i++)
                    {
                        if (!ChildList[i].transform.IsChildOf(Target.transform))
                        {
                            ChildList.RemoveAt(i--);

                            continue;
                        }

                        Color selfColor = ColorDic[ChildList[i]];

                        if (AlphaOnly)
                        {
                            ChildList[i].material.SetColor("_Color", new Color(selfColor.r, selfColor.g, selfColor.b, selfColor.a * Target.material.GetColor("_Color").a));
                        }
                        else
                        {
                            ChildList[i].material.SetColor("_Color", selfColor * Target.material.GetColor("_Color"));
                        }
                    }
                }

                BackwardFinish();
            }
        }
    }

    public override bool InDestination
    {
        get
        {
            if (Target.material.GetColor("_Color").Equal(Destination))
            {
                InDestination_ = true;
            }
            else
            {
                InDestination_ = false;
            }

            return InDestination_;
        }
        set
        {
            InDestination_ = value;

            InPause = false;
            InForward = false;
            InBackward = false;

            if (InDestination_)
            {
                Target.material.SetColor("_Color", Destination);

                if (Group)
                {
                    for (int i = 0; i < ChildList.Count; i++)
                    {
                        if (!ChildList[i].transform.IsChildOf(Target.transform))
                        {
                            ChildList.RemoveAt(i--);

                            continue;
                        }

                        Color selfColor = ColorDic[ChildList[i]];

                        if (AlphaOnly)
                        {
                            ChildList[i].material.SetColor("_Color", new Color(selfColor.r, selfColor.g, selfColor.b, selfColor.a * Target.material.GetColor("_Color").a));
                        }
                        else
                        {
                            ChildList[i].material.SetColor("_Color", selfColor * Target.material.GetColor("_Color"));
                        }
                    }
                }

                ForwardFinish();
            }
        }
    }

    public bool Group;
    public bool AlphaOnly;

    public Color Delta;
    public Color Origin;
    public Color Destination;
    public Renderer Target;
    public CurveFunctionC Func;

    public List<Renderer> ChildList = new List<Renderer>();
    public Dictionary<Renderer, Color> ColorDic = new Dictionary<Renderer, Color>();

    #endregion

    public TweenRenderer(Renderer target, Color origin, Color destination, float duration, bool originActive, bool destActive, Curve curve, bool cg = false, bool group = false) : base(cg, curve, target)
    {
        Func = ManaAnim.CurveFuncDicC[curve];
        Target = target;

        InForward = false;
        InBackward = false;

        Delta = destination - origin;
        Origin = origin;
        Group = group;
        Duration = duration;
        DestActive = destActive;
        Destination = destination;
        OriginActive = originActive;
    }

    public override bool StartForward()
    {
        if (base.StartForward())
        {
            return true;
        }

        if (Group)
        {
            Renderer[] renderers = Target.GetComponentsInChildren<Renderer>();

            ChildList = new List<Renderer>();

            for (int i = 1; i < renderers.Length; i++)
            {
                Renderer renderer = renderers[i];

                ChildList.Add(renderer);

                if (!ColorDic.ContainsKey(renderer))
                {
                    ColorDic.Add(renderer, renderer.material.GetColor("_Color"));
                }
            }


            List<Renderer> keyList = ColorDic.Keys.ToList();

            for (int i = 0; i < keyList.Count; i++)
            {
                if (!ChildList.Contains(keyList[i]))
                {
                    ColorDic.Remove(keyList[i]);
                }
            }
        }

        if (InBackward)
        {
            InBackward = false;

            Timer = ManaAnim.GetTimerColor(Target.material.GetColor("_Color"), Duration, Origin, Delta, Curve);
        }

        return false;
    }

    public override bool StartBackward()
    {
        if (base.StartBackward())
        {
            return true;
        }

        if (Group)
        {
            Renderer[] renderers = Target.GetComponentsInChildren<Renderer>();

            ChildList = new List<Renderer>();

            for (int i = 1; i < renderers.Length; i++)
            {
                Renderer renderer = renderers[i];

                ChildList.Add(renderer);

                if (!ColorDic.ContainsKey(renderer))
                {
                    ColorDic.Add(renderer, renderer.material.GetColor("_Color"));
                }
            }


            List<Renderer> keyList = ColorDic.Keys.ToList();

            for (int i = 0; i < keyList.Count; i++)
            {
                if (!ChildList.Contains(keyList[i]))
                {
                    ColorDic.Remove(keyList[i]);
                }
            }
        }

        if (InForward)
        {
            InForward = false;

            Timer = ManaAnim.GetTimerColor(Target.material.GetColor("_Color"), Duration, Destination, new Color(-Delta.r, -Delta.g, -Delta.b, -Delta.a), Curve);
        }

        return false;
    }


    public override bool DoForward()
    {
        Timer += Time.fixedDeltaTime;

        if (Timer > Duration)
        {
            InDestination = true;

            if (OnForwardFinish != null)
            {
                OnForwardFinish.Invoke();
            }

            SetLoop(EventType.ForwardFinish);

            return true;
        }
        else
        {
            Target.material.SetColor("_Color", Func(Timer, Duration, Origin, Delta));

            if (Group)
            {
                for (int i = 0; i < ChildList.Count; i++)
                {
                    if (!ChildList[i].transform.IsChildOf(Target.transform))
                    {
                        ChildList.RemoveAt(i--);

                        continue;
                    }

                    Color selfColor = ColorDic[ChildList[i]];

                    if (AlphaOnly)
                    {
                        ChildList[i].material.SetColor("_Color", new Color(selfColor.r, selfColor.g, selfColor.b, selfColor.a * Target.material.GetColor("_Color").a));
                    }
                    else
                    {
                        ChildList[i].material.SetColor("_Color", selfColor * Target.material.GetColor("_Color"));
                    }
                }
            }

            return false;
        }
    }

    public override bool DoBackward()
    {
        Timer += Time.fixedDeltaTime;

        if (Timer > Duration)
        {
            InOrigin = true;

            if (OnBackwardFinish != null)
            {
                OnBackwardFinish.Invoke();
            }

            SetLoop(EventType.BackwardFinish);

            return true;
        }
        else
        {
            Target.material.SetColor("_Color", Func(Timer, Duration, Destination, new Color(-Delta.r, -Delta.g, -Delta.b, -Delta.a)));

            if (Group)
            {
                for (int i = 0; i < ChildList.Count; i++)
                {
                    if (!ChildList[i].transform.IsChildOf(Target.transform))
                    {
                        ChildList.RemoveAt(i--);

                        continue;
                    }

                    Color selfColor = ColorDic[ChildList[i]];

                    if (AlphaOnly)
                    {
                        ChildList[i].material.SetColor("_Color", new Color(selfColor.r, selfColor.g, selfColor.b, selfColor.a * Target.material.GetColor("_Color").a));
                    }
                    else
                    {
                        ChildList[i].material.SetColor("_Color", selfColor * Target.material.GetColor("_Color"));
                    }
                }
            }

            return false;
        }
    }
}