示例#1
0
        public override void PreProcess(SKCanvas canvas, SKRect renderBounds, SKPaint paint)
        {
            // Progress moves from 0 to 2 bring that back to a value moving from 0 to 1 to 0
            float progress = _progress;

            if (progress > 1)
            {
                progress = 2 - progress;
            }

            float alphaMultiplier;

            if (_progress <= 1f)
            {
                if (Properties.BrightenTransitionMode.CurrentValue == StrobeTransitionMode.Linear)
                {
                    alphaMultiplier = progress;
                }
                else if (Properties.BrightenTransitionMode.CurrentValue == StrobeTransitionMode.Eased)
                {
                    alphaMultiplier = (float)Easings.BounceEaseInOut(progress);
                }
                else
                {
                    alphaMultiplier = MathF.Round(progress, 0);
                }
            }
            else
            {
                if (Properties.DimTransitionMode.CurrentValue == StrobeTransitionMode.Linear)
                {
                    alphaMultiplier = progress;
                }
                else if (Properties.DimTransitionMode.CurrentValue == StrobeTransitionMode.Eased)
                {
                    alphaMultiplier = (float)Easings.BounceEaseInOut(progress);
                }
                else
                {
                    alphaMultiplier = MathF.Round(progress, 0);
                }
            }

            if (Properties.Inverted == true)
            {
                alphaMultiplier = 1 - alphaMultiplier;
            }

            paint.ColorF = paint.ColorF.WithAlpha(paint.ColorF.Alpha * alphaMultiplier);
        }
示例#2
0
    // Token: 0x06000001 RID: 1 RVA: 0x00002050 File Offset: 0x00000250
    public static float Interpolate(float p, Easings.Functions function)
    {
        switch (function)
        {
        default:
            return(Easings.Linear(p));

        case Easings.Functions.QuadraticEaseIn:
            return(Easings.QuadraticEaseIn(p));

        case Easings.Functions.QuadraticEaseOut:
            return(Easings.QuadraticEaseOut(p));

        case Easings.Functions.QuadraticEaseInOut:
            return(Easings.QuadraticEaseInOut(p));

        case Easings.Functions.CubicEaseIn:
            return(Easings.CubicEaseIn(p));

        case Easings.Functions.CubicEaseOut:
            return(Easings.CubicEaseOut(p));

        case Easings.Functions.CubicEaseInOut:
            return(Easings.CubicEaseInOut(p));

        case Easings.Functions.QuarticEaseIn:
            return(Easings.QuarticEaseIn(p));

        case Easings.Functions.QuarticEaseOut:
            return(Easings.QuarticEaseOut(p));

        case Easings.Functions.QuarticEaseInOut:
            return(Easings.QuarticEaseInOut(p));

        case Easings.Functions.QuinticEaseIn:
            return(Easings.QuinticEaseIn(p));

        case Easings.Functions.QuinticEaseOut:
            return(Easings.QuinticEaseOut(p));

        case Easings.Functions.QuinticEaseInOut:
            return(Easings.QuinticEaseInOut(p));

        case Easings.Functions.SineEaseIn:
            return(Easings.SineEaseIn(p));

        case Easings.Functions.SineEaseOut:
            return(Easings.SineEaseOut(p));

        case Easings.Functions.SineEaseInOut:
            return(Easings.SineEaseInOut(p));

        case Easings.Functions.CircularEaseIn:
            return(Easings.CircularEaseIn(p));

        case Easings.Functions.CircularEaseOut:
            return(Easings.CircularEaseOut(p));

        case Easings.Functions.CircularEaseInOut:
            return(Easings.CircularEaseInOut(p));

        case Easings.Functions.ExponentialEaseIn:
            return(Easings.ExponentialEaseIn(p));

        case Easings.Functions.ExponentialEaseOut:
            return(Easings.ExponentialEaseOut(p));

        case Easings.Functions.ExponentialEaseInOut:
            return(Easings.ExponentialEaseInOut(p));

        case Easings.Functions.ElasticEaseIn:
            return(Easings.ElasticEaseIn(p));

        case Easings.Functions.ElasticEaseOut:
            return(Easings.ElasticEaseOut(p));

        case Easings.Functions.ElasticEaseInOut:
            return(Easings.ElasticEaseInOut(p));

        case Easings.Functions.BackEaseIn:
            return(Easings.BackEaseIn(p));

        case Easings.Functions.BackEaseOut:
            return(Easings.BackEaseOut(p));

        case Easings.Functions.BackEaseInOut:
            return(Easings.BackEaseInOut(p));

        case Easings.Functions.BounceEaseIn:
            return(Easings.BounceEaseIn(p));

        case Easings.Functions.BounceEaseOut:
            return(Easings.BounceEaseOut(p));

        case Easings.Functions.BounceEaseInOut:
            return(Easings.BounceEaseInOut(p));
        }
    }
    void Update()
    {
        transform.position -= Vector3.forward * Time.deltaTime * playModel.worldSpeed_Current;

        timer += Time.deltaTime;
        if (timer <= quarterLife)
        {
            transform.localScale = Vector3.Lerp(Vector3.zero, Vector3.one * gameModel.f_Rockets_ExplosionBallSize, Easings.BounceEaseInOut(timer / quarterLife));
        }
        else if (timer >= quarterLife * 3)
        {
            transform.localScale = Vector3.Lerp(Vector3.one * gameModel.f_Rockets_ExplosionBallSize, Vector3.zero, Easings.BounceEaseInOut((timer - (3 * quarterLife)) / quarterLife));
        }
    }