setDelay() public method

public setDelay ( float delay ) : LTDescr
delay float
return LTDescr
コード例 #1
0
        //IEnumerator HandleTweenDelayed()
        //{
        //    float counter = 0;
        //    while (counter < delay)
        //    {
        //        counter += Time.deltaTime;
        //        yield return null;
        //    }
        //    HandleTween();
        //}

        //IEnumerator Activate()
        //{
        //    float counter = 0;
        //    while (counter < delay)
        //    {
        //        counter += Time.deltaTime;
        //        yield return null;
        //    }
        //    objectToAnimate.SetActive(true);
        //}

        public void HandleTween()
        {
            if (objectToAnimate == null)
            {
                objectToAnimate = gameObject;
            }

            switch (animationType)
            {
            case UIAnimationType.Fade:
                Fade();
                break;

            case UIAnimationType.Move:
                Move();
                break;

            case UIAnimationType.MoveAbsolute:
                MoveAbsolute();
                break;

            case UIAnimationType.Scale:
                Scale();
                break;

            case UIAnimationType.ScaleX:
                ScaleX();
                break;

            case UIAnimationType.ScaleY:
                ScaleY();
                break;

            default:
                break;
            }

            _tweenObject.setDelay(delay);
            _tweenObject.setEase(easeType);

            if (loop)
            {
                _tweenObject.loopCount = int.MaxValue;
            }
            if (pingpong)
            {
                _tweenObject.setLoopPingPong();
            }
        }
コード例 #2
0
ファイル: UITweener.cs プロジェクト: DantesGearbox/8x8Game
    private void Animate()
    {
        switch (animationType)
        {
        case UIAnimationTypes.Fade:
            tweenObject = Fade();
            break;

        case UIAnimationTypes.Move:
            tweenObject = Move();
            break;

        case UIAnimationTypes.Scale:
            tweenObject = Scale();
            break;
        }

        tweenObject.setDelay(delay);
        tweenObject.setEase(easeType);

        if (loop)
        {
            tweenObject.setLoopClamp();
        }
        if (pingpong)
        {
            tweenObject.setLoopPingPong();
        }
    }
コード例 #3
0
 private static LTDescr SetLastParameters(LTDescr tween, float delay, Action onCompleteAction, Ease ease)
 {
     tween.setDelay(delay);
     tween.setOnComplete(onCompleteAction);
     tween = SetEase(tween, ease);
     return(tween);
 }
コード例 #4
0
 public LTSeq append(LTDescr tween)
 {
     this.current.tween      = tween;
     this.current.totalDelay = this.addPreviousDelays();
     tween.setDelay(this.current.totalDelay);
     return(this.addOn());
 }
コード例 #5
0
 public LTSeq append(LTDescr tween)
 {
     current.tween      = tween;
     current.totalDelay = addPreviousDelays();
     tween.setDelay(current.totalDelay);
     return(addOn());
 }
コード例 #6
0
        void Start()
        {
            LTDescr ltDescr = LeanTween.rotateAroundLocal(gameObject, axis, add, time);

            ltDescr.setDelay(delay);
            ltDescr.setRepeat(repeat);
            ltDescr.setDestroyOnComplete(destroyOnComplete);
        }
コード例 #7
0
ファイル: BuffTipsView.cs プロジェクト: mengtest/HjqstSource
        private void PlayMoveLocalYAnimation(float toY, float time, float delay)
        {
            LTDescr ltDescr = LeanTween.moveLocalY(gameObject, toY, time);

            ltDescr.tweenType = LeanTweenType.linear;
            ltDescr.setIgnoreTimeScale(true);
            ltDescr.setDelay(delay);
        }
コード例 #8
0
    public LTSeq insert(LTDescr tween)
    {
        this.current.tween = tween;

        tween.setDelay(addPreviousDelays());

        return(addOn());
    }
コード例 #9
0
ファイル: BuffTipsView.cs プロジェクト: mengtest/HjqstSource
        private void PlayScaleAnimation(float toSale, float time, float delay)
        {
            Vector2 toScaleVector = new Vector2(toSale, toSale);
            LTDescr ltDescr       = LeanTween.scale(gameObject, toScaleVector, time);

            ltDescr.tweenType = LeanTweenType.easeInOutSine;
            ltDescr.setIgnoreTimeScale(true);
            ltDescr.setDelay(delay);
        }
コード例 #10
0
    public void Execute()
    {
        switch (tweenType)
        {
        case TweenType.Move:
        {
            descr = LeanTween.move(gameObject, to, duration);
        }
        break;

        case TweenType.MoveX:
        {
            descr = LeanTween.moveX(gameObject, toX, duration);
        }
        break;

        case TweenType.MoveY:
        {
            descr = LeanTween.moveY(gameObject, toY, duration);
        }
        break;

        case TweenType.Scale:
        {
            descr = LeanTween.scale(gameObject, to, duration);
        }
        break;

        case TweenType.ScaleX:
        {
            descr = LeanTween.scaleX(gameObject, toX, duration);
        }
        break;

        case TweenType.ScaleY:
        {
            descr = LeanTween.scaleY(gameObject, toY, duration);
        }
        break;

        case TweenType.Rotate:
        {
            descr = LeanTween.rotate(gameObject, new Vector3(0, 0, rotation), duration);
        }
        break;
        }

        descr.setDelay(delay).setEase(easeType);
        if (loop)
        {
            descr.loopCount = int.MaxValue;
        }
        if (pingpong)
        {
            descr.setLoopPingPong();
        }
    }
コード例 #11
0
        public void startAction()
        {
            _canvasGroup.alpha = fromAlpha;
            LTDescr ltDescr = LeanTween.value(gameObject, fromAlpha, toAlpha, time);

            ltDescr.setDelay(delay);
            ltDescr.setEase(LeanTweenType.easeInOutSine);
            ltDescr.setOnUpdate(OnUpdateFloat);
        }
コード例 #12
0
        public void StartAction()
        {
            rectTransform.anchoredPosition = initialAnchoredPosition;
            LTDescr ltDescr = LeanTween.value(gameObject, initialAnchoredPosition, Vector2.zero, time);

            ltDescr.tweenType = LeanTweenType.easeInOutSine;
            ltDescr.setDelay(delay);
            ltDescr.setOnUpdateVector2(OnUpdateAnchoredPosition);
        }
コード例 #13
0
ファイル: BuffTipsView.cs プロジェクト: mengtest/HjqstSource
        private void PlayAlphaAnimation(float toAlpha, float time, float delay)
        {
            LTDescr ltDescr = LeanTween.value(gameObject, 1, toAlpha, time);

            ltDescr.tweenType = LeanTweenType.easeInOutSine;
            ltDescr.setIgnoreTimeScale(true);
            ltDescr.setOnUpdate(OnUpdateAlpha);
            ltDescr.setOnComplete(OnAlphaAnimationComplemte);
            ltDescr.setDelay(delay);
        }
コード例 #14
0
 private void AnimateScale(Vector3 fromScale, Vector3 toScale, float delayTime)
 {
     if (startPositionOffset)
     {
         objectToAnimate.GetComponent <RectTransform>().localScale = fromScale;
     }
     tweenObject = LeanTween.scale(objectToAnimate, toScale, duration);
     tweenObject.setDelay(delayTime);
     tweenObject.setEase(easeType);
 }
コード例 #15
0
        public void StartAction()
        {
            _canvasGroup.alpha = 0f;
            LTDescr ltDescr = LeanTween.value(gameObject, 0, 1, time);

            ltDescr.setDelay(delay);
            ltDescr.setEase(LeanTweenType.easeInOutSine);
            ltDescr.setOnUpdate(OnUpdateFloat);
            ltDescr.setIgnoreTimeScale(true);
        }
コード例 #16
0
        void Start()
        {
            LTDescr ltDescr = LeanTween.value(gameObject, colorFrom, colorTo, time);

            ltDescr.setDelay(delay);
            ltDescr.loopType = LeanTweenType.pingPong;
            ltDescr.setOnUpdateColor(OnUpdateColor);
            ltDescr.setDestroyOnComplete(destroyOnComplete);
            ltDescr.setRepeat(repeatTimes);
        }
コード例 #17
0
    public void AnimateMovement(Vector3 fromMovement, Vector3 toMovement, float delayTime)
    {
        AssignObjectToAnimate();
        RectTransform rectTransform = objectToAnimate.GetComponent <RectTransform>();

        rectTransform.anchoredPosition = fromMovement;

        tweenObject = LeanTween.move(rectTransform, toMovement, duration);
        tweenObject.setDelay(delayTime);
        tweenObject.setEase(easeType);
    }
コード例 #18
0
    // Use this for initialization
    void Start()
    {
        LTDescr tween = LeanTween.move(this.gameObject, new Vector3(0, 3, 0), 3);

        tween.setFrom(new Vector3(0, -5, 0));
        tween.setDelay(2);

        tween.setEase(LeanTweenType.easeInBounce);
        tween.setOnUpdate(EscreveValor);
        tween.setEase(LeanTweenType.easeOutQuad);
    }
コード例 #19
0
    /**
     * Retrieve a sequencer object where you can easily chain together tweens and methods one after another
     *
     * @method add (tween)
     * @return {LTSeq} LTSeq an object that you can add tweens, methods and time on to
     * @example
     * var seq = LeanTween.sequence();<br>
     * seq.append( LeanTween.move(cube1, Vector3.one * 10f, 1f) ); // do a move tween<br>
     * seq.append( LeanTween.rotateAround( avatar1, Vector3.forward, 360f, 1f ) ); // then do a rotate tween<br>
     */
    public LTSeq append(LTDescr tween)
    {
        this.current.tween = tween;

//		Debug.Log("tween:" + tween + " delay:" + this.current.totalDelay);

        this.current.totalDelay = addPreviousDelays();

        tween.setDelay(this.current.totalDelay);

        return(addOn());
    }
コード例 #20
0
ファイル: LeanTweener.cs プロジェクト: Valensta/otherside
    public void Init()
    {
        //   Debug.Log("Initializing " + target.gameObject.name + "\n");
        if (target == null)
        {
            Debug.Log("Missing target for " + this.gameObject.name + " LeanTweener\n"); return;
        }
        LTDescr l = null;

        LeanTween.cancel(target);
        switch (type)
        {
        case TweenType.Scale:
            target.transform.localScale = init_vector;
            l = LeanTween.scale(target, vector, time).setIgnoreTimeScale(ignoreTimeScale);
            break;

        case TweenType.Rotate:
            l = LeanTween.rotateZ(target, value, time).setIgnoreTimeScale(ignoreTimeScale);
            break;

        case TweenType.ColorChange:
            l = LeanTween.color(target, my_color, time).setIgnoreTimeScale(ignoreTimeScale);
            break;

        default:
            return;
        }

        tweening = true;
        if (delay > 0)
        {
            l.setDelay(delay);
        }
        if (leantweentype != LeanTweenType.notUsed)
        {
            l.setEase(leantweentype);
        }
        if (pingpong > -99)
        {
            l.setLoopPingPong(pingpong);
        }



        if (duration != -99)
        {
            StartCoroutine(StopMeSoon());
        }
    }
コード例 #21
0
ファイル: UITweener.cs プロジェクト: Mugiban/Impulse
    public void Show()
    {
        rect        = GetComponent <RectTransform>();
        canvasGroup = GetComponent <CanvasGroup>();
        if (objectToAnimate == null)
        {
            objectToAnimate = gameObject;
        }
        switch (transitionType)
        {
        case UITransitionType.Move:
            Move();
            break;

        case UITransitionType.Scale:
            Scale();
            break;

        case UITransitionType.Fade:
            Fade();
            break;
        }

        tweenObject.setDelay(delay);
        tweenObject.setEase(easeType);
        tweenObject.setIgnoreTimeScale(true);

        if (loop)
        {
            tweenObject.loopCount = int.MaxValue;
        }

        if (pingpong)
        {
            tweenObject.setLoopPingPong();
        }
    }
コード例 #22
0
        // Code that runs on entering the state.
        public override void OnEnter()
        {
            var len = pathPoints.Length;

            Vector3[] tweenVector = new Vector3[len];

            for (var i = 0; i < len; i++)
            {
                tweenVector [i] = pathPoints [i].Value;
            }

            GameObject go = Fsm.GetOwnerDefaultTarget(gameObject);

            Fsm.Event(onStartEvent);

            LTDescr tween = LeanTween.move(go, tweenVector, time.Value);

            LeanTweenID.Value = tween.id;

            tween.setOrientToPath(orientToPath.Value);
            tween.setAxis(axis.Value);
            tween.setEase(easeType);
            tween.setDelay(delay.Value);

            if (noOfRepeat.Value > 0)
            {
                tween.setRepeat(noOfRepeat.Value);
            }

            switch (LoopType)
            {
            case LTLoop.clamp:
                tween.setLoopClamp();
                break;

            case LTLoop.once:
                tween.setLoopOnce();
                break;

            case LTLoop.pingpong:
                tween.setLoopPingPong();
                break;
            }

            tween.setOnComplete(doOnComplete);
            tween.setOnUpdate(doOnUpdate);
            tween.setUseEstimatedTime(useEstimatedTime.Value);
            tween.setUseFrames(useFrames.Value);
        }
コード例 #23
0
        // Code that runs on entering the state.
        public override void OnEnter()
        {
            GameObject go = Fsm.GetOwnerDefaultTarget(gameObject);

            GameObject tGo = targetGameObject.Value;

            if (tGo != null)
            {
                tempVector = tGo.transform.position;
            }
            else
            {
                tempVector = vector.Value;
            }
            Fsm.Event(onStartEvent);

            LTDescr tween = LeanTween.move(go, tempVector, time.Value);

            LeanTweenID.Value = tween.id;

            tween.setEase(easeType);
            tween.setDelay(delay.Value);

            if (noOfRepeat.Value > 0)
            {
                tween.setRepeat(noOfRepeat.Value);
            }

            switch (LoopType)
            {
            case LTLoop.clamp:
                tween.setLoopClamp();
                break;

            case LTLoop.once:
                tween.setLoopOnce();
                break;

            case LTLoop.pingpong:
                tween.setLoopPingPong();
                break;
            }

            tween.setOnComplete(doOnComplete);
            tween.setOnUpdate(doOnUpdate);
            tween.setUseEstimatedTime(useEstimatedTime.Value);
            tween.setUseFrames(useFrames.Value);
        }
コード例 #24
0
        private void PlayDebutAnimation(GameObject contentItemGameObject, float delay, bool isLast)
        {
            float   startY             = contentItemGameObject.transform.localPosition.y - scrollRect.GetComponent <RectTransform>().rect.size.y;
            Vector3 startLocalPosition = contentItemGameObject.transform.localPosition;

            startLocalPosition.y = startY;
            float endY = contentItemGameObject.transform.localPosition.y;

            contentItemGameObject.transform.localPosition = startLocalPosition;
            LTDescr ltDescr = LeanTween.moveLocalY(contentItemGameObject, endY, 0.6f);

            ltDescr.tweenType = LeanTweenType.easeInSine;
            ltDescr.setDelay(delay + _shouldPlayInitAnimationDelay);

            if (isLast)
            {
                ltDescr.setOnComplete(OnInitComplete);
            }
        }
コード例 #25
0
    public void HandleTween()
    {
        if (ObjectToAnimate == null)
        {
            ObjectToAnimate = gameObject;
        }

        switch (AnimationType)
        {
        case UIAnimationTypes.Fade:
            Fade();
            break;

        case UIAnimationTypes.Move:
            MoveAbsolute();
            break;

        case UIAnimationTypes.Scale:
            Scale();
            break;

        case UIAnimationTypes.ScaleX:
            Scale();
            break;

        case UIAnimationTypes.ScaleY:
            Scale();
            break;
        }

        _tweenObject.setDelay(Delay);
        _tweenObject.setEase(EaseType);

        if (Loop)
        {
            _tweenObject.loopCount = int.MaxValue;
        }

        if (PingPong)
        {
            _tweenObject.setLoopPingPong();
        }
    }
コード例 #26
0
    public void HandleTween()
    {
        if (_objectToAnimate == null)
        {
            _objectToAnimate = gameObject;
        }

        switch (animationType)
        {
        case AnimationType.MOVE:
            MoveAbsolute();
            break;

        case AnimationType.SCALE:
            Scale();
            break;

        case AnimationType.SCALEX:
            Scale();
            break;

        case AnimationType.SCALEY:
            Scale();
            break;

        default:
            throw new ArgumentOutOfRangeException();
        }

        _tweenObject.setDelay(delay);
        _tweenObject.setEase(easeType);

        if (loop)
        {
            _tweenObject.loopCount = int.MaxValue;
        }

        if (pingpong)
        {
            _tweenObject.setLoopPingPong();
        }
    }
コード例 #27
0
        protected virtual void ApplyAdditionalSettings(LTDescr tween)
        {
            tween.setDelay(animationSettings.Delay)
            .setIgnoreTimeScale(animationSettings.IgnoreTimeScale);

            if (animationSettings.Easing == LeanTweenType.animationCurve)
            {
                tween.setEase(animationSettings.AnimationCurve);
            }
            else
            {
                tween.setEase(animationSettings.Easing);
            }

            if (animationSettings.Loop)
            {
                tween.setLoopCount(animationSettings.Loops);
                tween.setLoopType(animationSettings.LoopType);
            }
        }
コード例 #28
0
        // Code that runs on entering the state.
        public override void OnEnter()
        {
            GameObject go = Fsm.GetOwnerDefaultTarget(gameObject);

            Vector3 final = go.transform.localPosition + vector.Value;

            Fsm.Event(onStartEvent);

            LTDescr tween = LeanTween.moveLocal(go, final, time.Value);

            LeanTweenID.Value = tween.id;

            tween.setEase(easeType);
            tween.setDelay(delay.Value);

            if (noOfRepeat.Value > 0)
            {
                tween.setRepeat(noOfRepeat.Value);
            }

            switch (LoopType)
            {
            case LTLoop.clamp:
                tween.setLoopClamp();
                break;

            case LTLoop.once:
                tween.setLoopOnce();
                break;

            case LTLoop.pingpong:
                tween.setLoopPingPong();
                break;
            }

            tween.setOnComplete(doOnComplete);
            tween.setOnUpdate(doOnUpdate);
            tween.setUseEstimatedTime(useEstimatedTime.Value);
            tween.setUseFrames(useFrames.Value);
        }
コード例 #29
0
    private void SetTweenSettings()
    {
        if (!LeanTween.isTweening(id))
        {
            return;
        }

        LTDescr descr = LeanTween.descr(id);

        if (descr == null)
        {
            return;
        }

        if (easeType == LeanTweenType.animationCurve)
        {
            descr.setEase(animationCurve);
        }
        else
        {
            descr.setEase(easeType);
        }

        descr.setDelay(delay);

        if (loop)
        {
            if (pingPong)
            {
                descr.setLoopPingPong(loopTimes);
            }
            else
            {
                descr.setLoopClamp(loopTimes);
            }
        }

        descr.setOnComplete(() => onCompleteCallback?.Invoke());
        descr.setDestroyOnComplete(destroyOnComplete);
    }
コード例 #30
0
        // Code that runs on entering the state.
        public override void OnEnter()
        {
            GameObject go = Fsm.GetOwnerDefaultTarget(gameObject);

            float final = go.transform.eulerAngles.x + degrees.Value;

            Fsm.Event(onStartEvent);

            LTDescr tween = LeanTween.rotate(go.GetComponent <RectTransform>(), final, time.Value);

            LeanTweenID.Value = tween.id;

            tween.setEase(easeType);
            tween.setDelay(delay.Value);

            if (noOfRepeat.Value > 0)
            {
                tween.setRepeat(noOfRepeat.Value);
            }

            switch (LoopType)
            {
            case LTLoop.clamp:
                tween.setLoopClamp();
                break;

            case LTLoop.once:
                tween.setLoopOnce();
                break;

            case LTLoop.pingpong:
                tween.setLoopPingPong();
                break;
            }

            tween.setOnComplete(doOnComplete);
            tween.setUseEstimatedTime(useEstimatedTime.Value);
            tween.setUseFrames(useFrames.Value);
        }