Esempio n. 1
0
        public override void ApplyStartValues(ILTAnimator parent)
        {
            this.parent = parent;
            switch (type)
            {
            case AnimationTarget.None:
                return;

            case AnimationTarget.Scale:
                StartAnimateScale(vector3Pair);
                return;

            case AnimationTarget.Rotation:
                StartAnimateRotation(vector3Pair);
                return;

            case AnimationTarget.Position:
                StartAnimateRectTransformPosition(vector2Pair);
                return;

            case AnimationTarget.Width:
                StartAnimateRectTransformWidth(floatPair);
                return;

            case AnimationTarget.Height:
                StartAnimateRectTransformHeight(floatPair);
                return;

            case AnimationTarget.WidthAndHeight:
                StartAnimateRectTransformWidthAndHeight(vector2Pair);
                return;

            case AnimationTarget.MinAnchor:
                StartAnimateRectTransformMinAnchor(vector2Pair);
                return;

            case AnimationTarget.MaxAnchor:
                StartAnimateRectTransformMaxAnchor(vector2Pair);
                return;

            case AnimationTarget.MinMaxAnchor:
                StartAnimateRectTransformMinMaxAnchors(vector4Pair);
                return;

            case AnimationTarget.TextColor:
                StartAnimateTmpColor(colorPair);
                return;

            case AnimationTarget.CanvasGroupAlpha:
                StartAnimateCanvasGroupAlpha(floatPair);
                return;

            case AnimationTarget.ImageColor:
                StartAnimateImageColor(colorPair);
                return;

            default:
                throw new ArgumentOutOfRangeException();
            }
        }
Esempio n. 2
0
        public virtual void SkipToEndIfStarted(ILTAnimator parent)
        {
            if (uniqueId == -1)
            {
                return;
            }

            this.parent   = parent;
            skippingToEnd = true;
            LeanTween.cancel(gameObject, uniqueId, true);
        }
Esempio n. 3
0
        public virtual void SkipToEnd(ILTAnimator parent)
        {
            this.parent = parent;
            if (uniqueId == -1)
            {
                TriggerAnimation(parent);
            }

            skippingToEnd = true;
            LeanTween.cancel(gameObject, uniqueId, true);
        }
        public override void TriggerAnimation(ILTAnimator parent)
        {
            base.TriggerAnimation(parent);
            switch (type)
            {
            case AnimationTarget.None:
                AnimateNone();
                break;

            case AnimationTarget.Position:
                AnimatePosition(vector3Pair);
                break;

            case AnimationTarget.PositionX:
                AnimatePositionX(floatPair);
                break;

            case AnimationTarget.PositionY:
                AnimatePositionY(floatPair);
                break;

            case AnimationTarget.PositionZ:
                AnimatePositionZ(floatPair);
                break;

            case AnimationTarget.Scale:
                AnimateScale(vector3Pair);
                break;

            case AnimationTarget.Rotation:
                AnimateRotation(vector3Pair);
                break;

            case AnimationTarget.RotationSpeedX:
                AnimateRotationSpeedX(floatPair);
                break;

            case AnimationTarget.RotationSpeedY:
                AnimateRotationSpeedY(floatPair);
                break;

            case AnimationTarget.RotationSpeedZ:
                AnimateRotationSpeedZ(floatPair);
                break;

            default:
                throw new ArgumentOutOfRangeException();
            }
        }
        public override void ApplyStartValues(ILTAnimator parent)
        {
            this.parent = parent;
            switch (type)
            {
            case AnimationTarget.None:
                break;

            case AnimationTarget.Position:
                StartAnimatePosition(vector3Pair);
                break;

            case AnimationTarget.PositionX:
                StartAnimatePositionX(floatPair);
                break;

            case AnimationTarget.PositionY:
                StartAnimatePositionY(floatPair);
                break;

            case AnimationTarget.PositionZ:
                StartAnimatePositionZ(floatPair);
                break;

            case AnimationTarget.Scale:
                StartAnimateScale(vector3Pair);
                break;

            case AnimationTarget.Rotation:
                StartAnimateRotation(vector3Pair);
                break;

            case AnimationTarget.RotationSpeedX:
                break;

            case AnimationTarget.RotationSpeedY:
                break;

            case AnimationTarget.RotationSpeedZ:
                break;

            default:
                throw new ArgumentOutOfRangeException();
            }
        }
        public override void TriggerAnimation(ILTAnimator parent)
        {
            base.TriggerAnimation(parent);
            switch (type)
            {
            case AnimationTarget.None:
                AnimateNone();
                break;

            case AnimationTarget.MaterialColor:
                AnimateMaterialColor(colorPair, false);
                break;

            case AnimationTarget.MaterialInstanceColor:
                AnimateMaterialColor(colorPair, true);
                break;

            case AnimationTarget.MaterialFloat:
                AnimateMaterialFloat(floatPair, false);
                break;

            case AnimationTarget.MaterialInstanceFloat:
                AnimateMaterialFloat(floatPair, true);
                break;

            case AnimationTarget.MaterialVector4:
                AnimateMaterialVector4(vector4Pair, false);
                break;

            case AnimationTarget.MaterialInstanceVector4:
                AnimateMaterialVector4(vector4Pair, true);
                break;

            default:
                throw new ArgumentOutOfRangeException();
            }
        }
        public override void ApplyStartValues(ILTAnimator parent)
        {
            this.parent = parent;
            switch (type)
            {
            case AnimationTarget.None:
                break;

            case AnimationTarget.MaterialColor:
                StartAnimateMaterialColor(colorPair, false);
                break;

            case AnimationTarget.MaterialInstanceColor:
                StartAnimateMaterialColor(colorPair, true);
                break;

            case AnimationTarget.MaterialFloat:
                StartAnimateMaterialFloat(floatPair, false);
                break;

            case AnimationTarget.MaterialInstanceFloat:
                StartAnimateMaterialFloat(floatPair, true);
                break;

            case AnimationTarget.MaterialVector4:
                StartAnimateMaterialVector4(vector4Pair, false);
                break;

            case AnimationTarget.MaterialInstanceVector4:
                StartAnimateMaterialVector4(vector4Pair, true);
                break;

            default:
                throw new ArgumentOutOfRangeException();
            }
        }
Esempio n. 8
0
 public abstract void ApplyStartValues(ILTAnimator parent);
Esempio n. 9
0
 public virtual void TriggerAnimation(ILTAnimator parent)
 {
     this.parent        = parent;
     this.skippingToEnd = false;
     // Handle animation type
 }
Esempio n. 10
0
        public override void TriggerAnimation(ILTAnimator parent)
        {
            base.TriggerAnimation(parent);
            switch (type)
            {
            case AnimationTarget.None:
                AnimateNone();
                return;

            case AnimationTarget.Scale:
                AnimateScale(vector3Pair);
                return;

            case AnimationTarget.Rotation:
                AnimateRotation(vector3Pair);
                return;

            case AnimationTarget.Position:
                AnimateRectTransformPosition(vector2Pair);
                return;

            case AnimationTarget.Width:
                AnimateRectTransformWidth(floatPair);
                return;

            case AnimationTarget.Height:
                AnimateRectTransformHeight(floatPair);
                return;

            case AnimationTarget.WidthAndHeight:
                AnimateRectTransformWidthAndHeight(vector2Pair);
                return;

            case AnimationTarget.MinAnchor:
                AnimateRectTransformMinAnchor(vector2Pair);
                return;

            case AnimationTarget.MaxAnchor:
                AnimateRectTransformMaxAnchor(vector2Pair);
                return;

            case AnimationTarget.MinMaxAnchor:
                AnimateRectTransformMinMaxAnchors(vector4Pair);
                return;

            case AnimationTarget.TextColor:
                AnimateTmpColor(colorPair);
                return;

            case AnimationTarget.CanvasGroupAlpha:
                AnimateCanvasGroupAlpha(floatPair);
                return;

            case AnimationTarget.ImageColor:
                AnimateImageColor(colorPair);
                return;

            default:
                throw new ArgumentOutOfRangeException();
            }
        }