void Awake()
 {
     if(tweenTarget == null) tweenTarget = this.gameObject;
     this.m_fStartTime = Time.realtimeSinceStartup;
     this.m_cImage = tweenTarget.GetComponent<Image>();
     this.m_delEase = GetEasingFunction(easeType);
 }

 private static IEnumerator<bool> AlphaFunction(MultiAdditionalCoroutineSprite sp, int time, double alpha, EasingFunction easing)
 {
     var sa = sp.Alpha;
     for (int i = 0; i < time; i++)
     {
         sp.Alpha = easing(i, time, sa, alpha - sa);
         yield return true;
     }
     sp.Alpha = alpha;
 }

 void Awake()
 {
     if(tweenTarget == null) tweenTarget = this.gameObject;
     this.m_fStartTime = Time.realtimeSinceStartup;
     this.m_delEase = GetEasingFunction(easeType);
     if(fromnow)
     {
         from = tweenTarget.transform.localScale;
     }
 }

 static void addCurve(object library, EasingFunction easingFunction, int resolution, string name)
 {
     var curvePresetLibraryType = Type.GetType("UnityEditor.CurvePresetLibrary, UnityEditor");
     var addMehtod = curvePresetLibraryType.GetMethod("Add");
     addMehtod.Invoke(library, new object[]
     {
         GenerateCurve(easingFunction, resolution),
         name
     });
 }

 private static IEnumerator<bool> BlinkFunction(MultiAdditionalCoroutineSprite sp, int time, double duraiton, EasingFunction easing)
 {
     while (true)
     {
         for (int i = 0; i < time; i++)
         {
             sp.Alpha = easing(i, time, 1, -duraiton);
             yield return true;
         }
     }
 }

 private static IEasing GetEasingFunctionFor(EasingFunction easingFunction)
 {
     switch (easingFunction)
     {
         case EasingFunction.Linear:
             return new LinearEasing();
         case EasingFunction.Quadratic:
             return new QuadraticEasing();
         case EasingFunction.Discrete:
             return new DiscreteEasing();
         default:
             throw new ArgumentOutOfRangeException("easingFunction");
     }
 }

        public static AnimationClock AnimateEasingEquation(
            DependencyObject element,
            DependencyProperty prop,
            EasingFunction function,            
            double to,
            int durationMS)
        {
            double from = double.IsNaN((double)element.GetValue(prop)) ?
                                0 :
                                (double)element.GetValue(prop);

            AnimationTimeline timeline = GetEasingAnimation(function, EasingMode.EaseIn, from, to, durationMS);
            return Animate(element, prop, timeline, durationMS, null, null, null);
        }

        public void SetTransitionOff(double time, Vector2 start, Vector2 end, float dur, EasingFunction funcX, EasingFunction funcY)
        {
            startPos = start;
            targPos = end;
            currPos = startPos;
            currPosX = (double)startPos.X;
            currPosY = (double)startPos.Y;

            easeX = funcX;
            easeY = funcY;

            startTime = time;
            transDuration = dur;

            state = TransState.Off;
        }

    private IEnumerator customEasing(Action cb, Vector3 to, float delay, float duration, EasingFunction function) {
        var from = isoObj.Position;
        yield return new WaitForSeconds(delay);
        float currentLerpTime = 0;

        while (currentLerpTime < duration) {
            currentLerpTime += Time.deltaTime;

            float x = (float)function(currentLerpTime);
            isoObj.Position = from + (to - from) * x;
            yield return null;
        }
        currentLerpTime = duration;
        isoObj.Position = to;

        cb();
    }

        public void SetTransitionOn(double time, Vector2 start, Vector2 end, float dur, EasingFunction funcX, EasingFunction funcY)
        {
            startPos = start;
            targPos = end;
            currPos = startPos;
            currPosX = (double)startPos.X;
            currPosY = (double)startPos.Y;

            easeX = funcX;
            easeY = funcY;

            startTime = time;
            transDuration = dur;

            state = TransState.On;

            Debug.WriteLine("Item Set to transition on!");
        }

 public static CoroutineFunction<MultiAdditionalCoroutineSprite> VerticalMove(int time, double y, EasingFunction easing)
 {
     return sp => CursorVerticalMoveFunction(sp, time, y, easing);
 }

 public static CoroutineFunction<MultiAdditionalCoroutineSprite> VerticalFadeOut(int time, double moving, EasingFunction moveEasing, EasingFunction fadeEasing)
 {
     return sp => VerticalFadeOutFunction(sp, time, moving, moveEasing, fadeEasing);
 }

		//instantiates a cached ease equation refrence:
		protected void SetEasingFunction(){
			switch (easeType){
			case EaseType.easeInQuad:
				ease  = new EasingFunction(easeInQuad);
				break;
			case EaseType.easeOutQuad:
				ease = new EasingFunction(easeOutQuad);
				break;
			case EaseType.easeInOutQuad:
				ease = new EasingFunction(easeInOutQuad);
				break;
			case EaseType.easeInCubic:
				ease = new EasingFunction(easeInCubic);
				break;
			case EaseType.easeOutCubic:
				ease = new EasingFunction(easeOutCubic);
				break;
			case EaseType.easeInOutCubic:
				ease = new EasingFunction(easeInOutCubic);
				break;
			case EaseType.easeInQuart:
				ease = new EasingFunction(easeInQuart);
				break;
			case EaseType.easeOutQuart:
				ease = new EasingFunction(easeOutQuart);
				break;
			case EaseType.easeInOutQuart:
				ease = new EasingFunction(easeInOutQuart);
				break;
			case EaseType.easeInQuint:
				ease = new EasingFunction(easeInQuint);
				break;
			case EaseType.easeOutQuint:
				ease = new EasingFunction(easeOutQuint);
				break;
			case EaseType.easeInOutQuint:
				ease = new EasingFunction(easeInOutQuint);
				break;
			case EaseType.easeInSine:
				ease = new EasingFunction(easeInSine);
				break;
			case EaseType.easeOutSine:
				ease = new EasingFunction(easeOutSine);
				break;
			case EaseType.easeInOutSine:
				ease = new EasingFunction(easeInOutSine);
				break;
			case EaseType.easeInExpo:
				ease = new EasingFunction(easeInExpo);
				break;
			case EaseType.easeOutExpo:
				ease = new EasingFunction(easeOutExpo);
				break;
			case EaseType.easeInOutExpo:
				ease = new EasingFunction(easeInOutExpo);
				break;
			case EaseType.easeInCirc:
				ease = new EasingFunction(easeInCirc);
				break;
			case EaseType.easeOutCirc:
				ease = new EasingFunction(easeOutCirc);
				break;
			case EaseType.easeInOutCirc:
				ease = new EasingFunction(easeInOutCirc);
				break;
			case EaseType.linear:
				ease = new EasingFunction(linear);
				break;
			case EaseType.spring:
				ease = new EasingFunction(spring);
				break;
			case EaseType.bounce:
				ease = new EasingFunction(bounce);
				break;
			case EaseType.easeInBack:
				ease = new EasingFunction(easeInBack);
				break;
			case EaseType.easeOutBack:
				ease = new EasingFunction(easeOutBack);
				break;
			case EaseType.easeInOutBack:
				ease = new EasingFunction(easeInOutBack);
				break;
			case EaseType.elastic:
				ease = new EasingFunction(elastic);
				break;
			}
		}

 /// <summary>
 /// Initializes a new instance of the <see cref="AnimationKeyframeBase"/> class.
 /// </summary>
 /// <param name="time">The keyframe time.</param>
 /// <param name="easingFunction">The keyframe's easing function.</param>
 public AnimationKeyframeBase(TimeSpan time, EasingFunction easingFunction = null)
 {
     this.time           = time;
     this.easingFunction = easingFunction;
 }

 private static IEnumerator<bool> CursorMoveFunction(MultiAdditionalCoroutineSprite sp, int time, double x, double y, EasingFunction easing)
 {
     var sy = sp.Y;
     var sx = sp.X;
     for (int i = 0; i < time; i++)
     {
         sp.Y = easing(i, time, sy, y - sy);
         sp.X = easing(i, time, sx, x - sx);
         yield return true;
     }
     sp.Y = y;
     sp.X = x;
 }

 public static ITween Tween(float start, float target, TimeSpan targetRunTime, EasingFunction easingFunction)
 {
     return new Tween(start, target, targetRunTime, TweenFactory.GetEasingFunctionFor(easingFunction));
 }

    public static Func<float, float, float, float, float> GetFunc(EasingFunction function)
    {
        switch (function)
        {
        case EasingFunction.Linear:
            return Easing.Linear;

        case EasingFunction.QuadEaseIn:
            return Easing.QuadEaseIn;
        case EasingFunction.QuadEaseOut:
            return Easing.QuadEaseOut;
        case EasingFunction.QuadEaseInOut:
            return Easing.QuadEaseInOut;
        case EasingFunction.QuadEaseOutIn:
            return Easing.QuadEaseOutIn;

        case EasingFunction.CubicEaseIn:
            return Easing.CubicEaseIn;
        case EasingFunction.CubicEaseOut:
            return Easing.CubicEaseOut;
        case EasingFunction.CubicEaseInOut:
            return Easing.CubicEaseInOut;
        case EasingFunction.CubicEaseOutIn:
            return Easing.CubicEaseOutIn;

        case EasingFunction.QuartEaseIn:
            return Easing.QuartEaseIn;
        case EasingFunction.QuartEaseOut:
            return Easing.QuartEaseOut;
        case EasingFunction.QuartEaseInOut:
            return Easing.QuartEaseInOut;
        case EasingFunction.QuartEaseOutIn:
            return Easing.QuartEaseOutIn;

        case EasingFunction.QuintEaseIn:
            return Easing.QuintEaseIn;
        case EasingFunction.QuintEaseOut:
            return Easing.QuintEaseOut;
        case EasingFunction.QuintEaseInOut:
            return Easing.QuintEaseInOut;
        case EasingFunction.QuintEaseOutIn:
            return Easing.QuintEaseOutIn;

        case EasingFunction.ExpoEaseIn:
            return Easing.ExpoEaseIn;
        case EasingFunction.ExpoEaseOut:
            return Easing.ExpoEaseOut;
        case EasingFunction.ExpoEaseInOut:
            return Easing.ExpoEaseInOut;
        case EasingFunction.ExpoEaseOutIn:
            return Easing.ExpoEaseOutIn;

        case EasingFunction.SineEaseIn:
            return Easing.SineEaseIn;
        case EasingFunction.SineEaseOut:
            return Easing.SineEaseOut;
        case EasingFunction.SineEaseInOut:
            return Easing.SineEaseInOut;
        case EasingFunction.SineEaseOutIn:
            return Easing.SineEaseOutIn;

        case EasingFunction.CircEaseIn:
            return Easing.CircEaseIn;
        case EasingFunction.CircEaseOut:
            return Easing.CircEaseOut;
        case EasingFunction.CircEaseInOut:
            return Easing.CircEaseInOut;
        case EasingFunction.CircEaseOutIn:
            return Easing.CircEaseOutIn;

        case EasingFunction.ElasticEaseIn:
            return Easing.ElasticEaseIn;
        case EasingFunction.ElasticEaseOut:
            return Easing.ElasticEaseOut;
        case EasingFunction.ElasticEaseInOut:
            return Easing.ElasticEaseInOut;
        case EasingFunction.ElasticEaseOutIn:
            return Easing.ElasticEaseOutIn;

        case EasingFunction.BounceEaseIn:
            return Easing.BounceEaseIn;
        case EasingFunction.BounceEaseOut:
            return Easing.BounceEaseOut;
        case EasingFunction.BounceEaseInOut:
            return Easing.BounceEaseInOut;
        case EasingFunction.BounceEaseOutIn:
            return Easing.BounceEaseOutIn;

        case EasingFunction.BackEaseIn:
            return Easing.BackEaseIn;
        case EasingFunction.BackEaseOut:
            return Easing.BackEaseOut;
        case EasingFunction.BackEaseInOut:
            return Easing.BackEaseInOut;
        case EasingFunction.BackEaseOutIn:
            return Easing.BackEaseOutIn;

        default:
            return Easing.Linear;
        }
//.........这里部分代码省略.........

 /// <summary>
 /// Converts an EasingFunction enum to the corresponding function.
 /// </summary>
 /// <param name="function">The EasingFunction enum.</param>
 /// <returns>The actual easing function.</returns
 /// >public int this[int key]
 public static float Ease(EasingFunction function, float t, float b, float c, float d)
 {
     return GetFunc(function)(t,b,c,d);
 }

 /// <summary>
 /// Moves the Object from its current position to newPosition using a easingFunction providing a duration this transition should take.
 /// After the transition to newPosition is complete the callbackFunction is called.
 /// </summary>
 /// <param name="newPostion">the new position</param>
 /// <param name="easingFunction">easing function used for the transition</param> http://easings.net for further help
 /// <param name="callback">called upon finished move</param>
 /// <param name="delay">initial delay</param>
 protected void moveTo(Vector3 newPostion, EasingFunction easingFunction, Action callback, float delay, float duration) {
     StartCoroutine(customEasing(callback, newPostion, delay, duration, easingFunction));
 }

 static AnimationCurve GenerateCurve(EasingFunction easingFunction, int resolution)
 {
     var curve = new AnimationCurve();
     for (var i = 0; i < resolution; ++i)
     {
         var time = i / (resolution - 1f);
         var value = (float)easingFunction(time, 0.0, 1.0, 1.0);
         var key = new Keyframe(time, value);
         curve.AddKey(key);
     }
     for (var i = 0; i < resolution; ++i)
     {
         curve.SmoothTangents(i, 0f);
     }
     return curve;
 }