setEaseInOutBack() public method

public setEaseInOutBack ( ) : LTDescr
return LTDescr
    // -------------------------------------------------------------------------------

    private void SetTweenType()
    {
        switch (TweenType)
        {
        case LeanTweenType.linear:              mTweenDescriptor.setEaseLinear(); break;

        case LeanTweenType.easeOutQuad:         mTweenDescriptor.setEaseOutQuad(); break;

        case LeanTweenType.easeInQuad:          mTweenDescriptor.setEaseInQuad(); break;

        case LeanTweenType.easeInOutQuad:       mTweenDescriptor.setEaseInOutQuad(); break;

        case LeanTweenType.easeInCubic:         mTweenDescriptor.setEaseInCubic(); break;

        case LeanTweenType.easeOutCubic:        mTweenDescriptor.setEaseOutCubic(); break;

        case LeanTweenType.easeInOutCubic:      mTweenDescriptor.setEaseInOutCubic(); break;

        case LeanTweenType.easeInQuart:         mTweenDescriptor.setEaseInQuart(); break;

        case LeanTweenType.easeOutQuart:        mTweenDescriptor.setEaseOutQuart(); break;

        case LeanTweenType.easeInOutQuart:      mTweenDescriptor.setEaseInOutQuart(); break;

        case LeanTweenType.easeInQuint:         mTweenDescriptor.setEaseInQuint(); break;

        case LeanTweenType.easeOutQuint:        mTweenDescriptor.setEaseOutQuint(); break;

        case LeanTweenType.easeInOutQuint:      mTweenDescriptor.setEaseInOutQuint(); break;

        case LeanTweenType.easeInSine:          mTweenDescriptor.setEaseInSine(); break;

        case LeanTweenType.easeOutSine:         mTweenDescriptor.setEaseOutSine(); break;

        case LeanTweenType.easeInOutSine:       mTweenDescriptor.setEaseInOutSine(); break;

        case LeanTweenType.easeInExpo:          mTweenDescriptor.setEaseInExpo(); break;

        case LeanTweenType.easeOutExpo:         mTweenDescriptor.setEaseOutExpo(); break;

        case LeanTweenType.easeInOutExpo:       mTweenDescriptor.setEaseInOutExpo(); break;

        case LeanTweenType.easeInCirc:          mTweenDescriptor.setEaseInCirc(); break;

        case LeanTweenType.easeOutCirc:         mTweenDescriptor.setEaseOutCirc(); break;

        case LeanTweenType.easeInOutCirc:       mTweenDescriptor.setEaseInOutCirc(); break;

        case LeanTweenType.easeInBounce:        mTweenDescriptor.setEaseInBounce(); break;

        case LeanTweenType.easeOutBounce:       mTweenDescriptor.setEaseOutBounce(); break;

        case LeanTweenType.easeInOutBounce:     mTweenDescriptor.setEaseInOutBounce(); break;

        case LeanTweenType.easeInBack:          mTweenDescriptor.setEaseInBack(); break;

        case LeanTweenType.easeOutBack:         mTweenDescriptor.setEaseOutBack(); break;

        case LeanTweenType.easeInOutBack:       mTweenDescriptor.setEaseInOutBack(); break;

        case LeanTweenType.easeInElastic:       mTweenDescriptor.setEaseInElastic(); break;

        case LeanTweenType.easeOutElastic:      mTweenDescriptor.setEaseOutElastic(); break;

        case LeanTweenType.easeInOutElastic:    mTweenDescriptor.setEaseInOutElastic(); break;

        case LeanTweenType.easeSpring:          mTweenDescriptor.setEaseSpring(); break;

        case LeanTweenType.easeShake:           mTweenDescriptor.setEaseShake(); break;

        case LeanTweenType.punch:               mTweenDescriptor.setEasePunch(); break;

        case LeanTweenType.once:                mTweenDescriptor.setLoopOnce(); break;

        case LeanTweenType.clamp:               mTweenDescriptor.setLoopClamp(); break;

        case LeanTweenType.pingPong:            mTweenDescriptor.setLoopPingPong(); break;

        case LeanTweenType.animationCurve:      Debug.LogError("Can't set AnimationCurve Tween this way..."); break;

        default:                                Debug.LogError("Invalid TweenType specified. Falling back to Linear"); break;
        }
    }
        private static LTDescr SetEase(LTDescr tween, Ease ease)
        {
            if ((int)ease >= 20)
            {
                switch (ease)
                {
                case Ease.Linear:
                    tween.setEaseLinear();
                    break;

                case Ease.QuadIn:
                    tween.setEaseInQuad();
                    break;

                case Ease.QuadOut:
                    tween.setEaseOutQuad();
                    break;

                case Ease.QuadInOut:
                    tween.setEaseInOutQuad();
                    break;

                case Ease.QuartIn:
                    tween.setEaseInQuart();
                    break;

                case Ease.QuartOut:
                    tween.setEaseOutQuart();
                    break;

                case Ease.QuartInOut:
                    tween.setEaseInOutQuart();
                    break;

                case Ease.QuintIn:
                    tween.setEaseInQuint();
                    break;

                case Ease.QuintOut:
                    tween.setEaseOutQuint();
                    break;

                case Ease.QuintInOut:
                    tween.setEaseInOutQuint();
                    break;

                case Ease.SineIn:
                    tween.setEaseInSine();
                    break;

                case Ease.SineOut:
                    tween.setEaseOutSine();
                    break;

                case Ease.SineInOut:
                    tween.setEaseInOutSine();
                    break;
                }
            }
            else
            {
                switch (ease)
                {
                case Ease.None:
                    break;

                case Ease.BackIn:
                    tween.setEaseInBack();
                    break;

                case Ease.BackOut:
                    tween.setEaseOutBack();
                    break;

                case Ease.BackInOut:
                    tween.setEaseInOutBack();
                    break;

                case Ease.BounceIn:
                    tween.setEaseInBounce();
                    break;

                case Ease.BounceOut:
                    tween.setEaseOutBounce();
                    break;

                case Ease.BounceInOut:
                    tween.setEaseInOutBounce();
                    break;

                case Ease.CircIn:
                    tween.setEaseInCirc();
                    break;

                case Ease.CircOut:
                    tween.setEaseOutCirc();
                    break;

                case Ease.CircInOut:
                    tween.setEaseInOutCirc();
                    break;

                case Ease.CubicIn:
                    tween.setEaseInCubic();
                    break;

                case Ease.CubicOut:
                    tween.setEaseOutCubic();
                    break;

                case Ease.CubicInOut:
                    tween.setEaseInOutCubic();
                    break;

                case Ease.ElasticIn:
                    tween.setEaseInElastic();
                    break;

                case Ease.ElasticOut:
                    tween.setEaseOutElastic();
                    break;

                case Ease.ElasticInOut:
                    tween.setEaseInOutElastic();
                    break;

                case Ease.ExpoIn:
                    tween.setEaseInExpo();
                    break;

                case Ease.ExpoOut:
                    tween.setEaseOutExpo();
                    break;

                case Ease.ExpoInOut:
                    tween.setEaseInOutExpo();
                    break;
                }
            }
            return(tween);
        }