zoukankan      html  css  js  c++  java
  • Android中的Interpolator

    Interpolator用于动画中的时间插值,其作用就是把0到1的浮点值变化映射到另一个浮点值变化。

      本文列出Android API提供的Interpolator的若干种实现,列出源码,并且用一个程序绘制出其数学曲线。(项目链接附在文后)。

     

    android:interpolator

       Interpolator 被用来修饰动画效果,定义动画的变化率,可以使存在的动画效果accelerated(加速),decelerated(减速),repeated(重复),bounced(弹跳)等。

      android中的文档内容如下:

     

      AccelerateDecelerateInterpolator 在动画开始与结束的地方速率改变比较慢,在中间的时候加速

         AccelerateInterpolator  在动画开始的地方速率改变比较慢,然后开始加速

       AnticipateInterpolator 开始的时候向后然后向前甩

       AnticipateOvershootInterpolator 开始的时候向后然后向前甩一定值后返回最后的值

       BounceInterpolator   动画结束的时候弹起

       CycleInterpolator 动画循环播放特定的次数,速率改变沿着正弦曲线

       DecelerateInterpolator 在动画开始的地方快然后慢

         LinearInterpolator   以常量速率改变

         OvershootInterpolator    向前甩一定值后再回到原来位置

    如果android定义的interpolators不符合你的效果也可以自定义interpolators

    AccelerateDecelerateInterpolator

    复制代码
    /**
     * An interpolator where the rate of change starts and ends slowly but
     * accelerates through the middle.
     * 
     */
    public class AccelerateDecelerateInterpolator implements Interpolator {
        public AccelerateDecelerateInterpolator() {
        }
        
        @SuppressWarnings({"UnusedDeclaration"})
        public AccelerateDecelerateInterpolator(Context context, AttributeSet attrs) {
        }
        
        public float getInterpolation(float input) {
            return (float)(Math.cos((input + 1) * Math.PI) / 2.0f) + 0.5f;
        }
    }
    复制代码

    AccelerateInterpolator

    复制代码
    /**
     * An interpolator where the rate of change starts out slowly and 
     * and then accelerates.
     *
     */
    public class AccelerateInterpolator implements Interpolator {
        private final float mFactor;
        private final double mDoubleFactor;
    
        public AccelerateInterpolator() {
            mFactor = 1.0f;
            mDoubleFactor = 2.0;
        }
        
        /**
         * Constructor
         * 
         * @param factor Degree to which the animation should be eased. Seting
         *        factor to 1.0f produces a y=x^2 parabola. Increasing factor above
         *        1.0f  exaggerates the ease-in effect (i.e., it starts even
         *        slower and ends evens faster)
         */
        public AccelerateInterpolator(float factor) {
            mFactor = factor;
            mDoubleFactor = 2 * mFactor;
        }
        
        public AccelerateInterpolator(Context context, AttributeSet attrs) {
            TypedArray a =
                context.obtainStyledAttributes(attrs, com.android.internal.R.styleable.AccelerateInterpolator);
            
            mFactor = a.getFloat(com.android.internal.R.styleable.AccelerateInterpolator_factor, 1.0f);
            mDoubleFactor = 2 * mFactor;
    
            a.recycle();
        }
        
        public float getInterpolation(float input) {
            if (mFactor == 1.0f) {
                return input * input;
            } else {
                return (float)Math.pow(input, mDoubleFactor);
            }
        }
    }
    复制代码

    AnticipateInterpolator

    复制代码
    /**
     * An interpolator where the change starts backward then flings forward.
     */
    public class AnticipateInterpolator implements Interpolator {
        private final float mTension;
    
        public AnticipateInterpolator() {
            mTension = 2.0f;
        }
    
        /**
         * @param tension Amount of anticipation. When tension equals 0.0f, there is
         *                no anticipation and the interpolator becomes a simple
         *                acceleration interpolator.
         */
        public AnticipateInterpolator(float tension) {
            mTension = tension;
        }
    
        public AnticipateInterpolator(Context context, AttributeSet attrs) {
            TypedArray a = context.obtainStyledAttributes(attrs,
                    com.android.internal.R.styleable.AnticipateInterpolator);
    
            mTension =
                    a.getFloat(com.android.internal.R.styleable.AnticipateInterpolator_tension, 2.0f);
    
            a.recycle();
        }
    
        public float getInterpolation(float t) {
            // a(t) = t * t * ((tension + 1) * t - tension)
            return t * t * ((mTension + 1) * t - mTension);
        }
    }
    复制代码

    AnticipateOvershootInterpolator

    复制代码
    /**
     * An interpolator where the change starts backward then flings forward and overshoots
     * the target value and finally goes back to the final value.
     */
    public class AnticipateOvershootInterpolator implements Interpolator {
        private final float mTension;
    
        public AnticipateOvershootInterpolator() {
            mTension = 2.0f * 1.5f;
        }
    
        /**
         * @param tension Amount of anticipation/overshoot. When tension equals 0.0f,
         *                there is no anticipation/overshoot and the interpolator becomes
         *                a simple acceleration/deceleration interpolator.
         */
        public AnticipateOvershootInterpolator(float tension) {
            mTension = tension * 1.5f;
        }
    
        /**
         * @param tension Amount of anticipation/overshoot. When tension equals 0.0f,
         *                there is no anticipation/overshoot and the interpolator becomes
         *                a simple acceleration/deceleration interpolator.
         * @param extraTension Amount by which to multiply the tension. For instance,
         *                     to get the same overshoot as an OvershootInterpolator with
         *                     a tension of 2.0f, you would use an extraTension of 1.5f.
         */
        public AnticipateOvershootInterpolator(float tension, float extraTension) {
            mTension = tension * extraTension;
        }
    
        public AnticipateOvershootInterpolator(Context context, AttributeSet attrs) {
            TypedArray a = context.obtainStyledAttributes(attrs, AnticipateOvershootInterpolator);
    
            mTension = a.getFloat(AnticipateOvershootInterpolator_tension, 2.0f) *
                    a.getFloat(AnticipateOvershootInterpolator_extraTension, 1.5f);
    
            a.recycle();
        }
    
        private static float a(float t, float s) {
            return t * t * ((s + 1) * t - s);
        }
    
        private static float o(float t, float s) {
            return t * t * ((s + 1) * t + s);
        }
    
        public float getInterpolation(float t) {
            // a(t, s) = t * t * ((s + 1) * t - s)
            // o(t, s) = t * t * ((s + 1) * t + s)
            // f(t) = 0.5 * a(t * 2, tension * extraTension), when t < 0.5
            // f(t) = 0.5 * (o(t * 2 - 2, tension * extraTension) + 2), when t <= 1.0
            if (t < 0.5f) return 0.5f * a(t * 2.0f, mTension);
            else return 0.5f * (o(t * 2.0f - 2.0f, mTension) + 2.0f);
        }
    }
    复制代码

    BounceInterpolator

    复制代码
    /**
     * An interpolator where the change bounces at the end.
     */
    public class BounceInterpolator implements Interpolator {
        public BounceInterpolator() {
        }
    
        @SuppressWarnings({"UnusedDeclaration"})
        public BounceInterpolator(Context context, AttributeSet attrs) {
        }
    
        private static float bounce(float t) {
            return t * t * 8.0f;
        }
    
        public float getInterpolation(float t) {
            // _b(t) = t * t * 8
            // bs(t) = _b(t) for t < 0.3535
            // bs(t) = _b(t - 0.54719) + 0.7 for t < 0.7408
            // bs(t) = _b(t - 0.8526) + 0.9 for t < 0.9644
            // bs(t) = _b(t - 1.0435) + 0.95 for t <= 1.0
            // b(t) = bs(t * 1.1226)
            t *= 1.1226f;
            if (t < 0.3535f) return bounce(t);
            else if (t < 0.7408f) return bounce(t - 0.54719f) + 0.7f;
            else if (t < 0.9644f) return bounce(t - 0.8526f) + 0.9f;
            else return bounce(t - 1.0435f) + 0.95f;
        }
    }
    复制代码

    CycleInterpolator

    复制代码
    /**
     * Repeats the animation for a specified number of cycles. The
     * rate of change follows a sinusoidal pattern.
     *
     */
    public class CycleInterpolator implements Interpolator {
        public CycleInterpolator(float cycles) {
            mCycles = cycles;
        }
        
        public CycleInterpolator(Context context, AttributeSet attrs) {
            TypedArray a =
                context.obtainStyledAttributes(attrs, com.android.internal.R.styleable.CycleInterpolator);
            
            mCycles = a.getFloat(com.android.internal.R.styleable.CycleInterpolator_cycles, 1.0f);
            
            a.recycle();
        }
        
        public float getInterpolation(float input) {
            return (float)(Math.sin(2 * mCycles * Math.PI * input));
        }
        
        private float mCycles;
    }
    复制代码

      参数为2时的曲线:

    DecelerateInterpolator

    复制代码
    /**
     * An interpolator where the rate of change starts out quickly and 
     * and then decelerates.
     *
     */
    public class DecelerateInterpolator implements Interpolator {
        public DecelerateInterpolator() {
        }
    
        /**
         * Constructor
         * 
         * @param factor Degree to which the animation should be eased. Setting factor to 1.0f produces
         *        an upside-down y=x^2 parabola. Increasing factor above 1.0f makes exaggerates the
         *        ease-out effect (i.e., it starts even faster and ends evens slower)
         */
        public DecelerateInterpolator(float factor) {
            mFactor = factor;
        }
        
        public DecelerateInterpolator(Context context, AttributeSet attrs) {
            TypedArray a =
                context.obtainStyledAttributes(attrs, com.android.internal.R.styleable.DecelerateInterpolator);
            
            mFactor = a.getFloat(com.android.internal.R.styleable.DecelerateInterpolator_factor, 1.0f);
            
            a.recycle();
        }
        
        public float getInterpolation(float input) {
            float result;
            if (mFactor == 1.0f) {
                result = (float)(1.0f - (1.0f - input) * (1.0f - input));
            } else {
                result = (float)(1.0f - Math.pow((1.0f - input), 2 * mFactor));
            }
            return result;
        }
        
        private float mFactor = 1.0f;
    }
    复制代码

    LinearInterpolator

    复制代码
    /**
     * An interpolator where the rate of change is constant
     *
     */
    public class LinearInterpolator implements Interpolator {
    
        public LinearInterpolator() {
        }
        
        public LinearInterpolator(Context context, AttributeSet attrs) {
        }
        
        public float getInterpolation(float input) {
            return input;
        }
    }
    复制代码

    OvershootInterpolator

    复制代码
    /**
     * An interpolator where the change flings forward and overshoots the last value
     * then comes back.
     */
    public class OvershootInterpolator implements Interpolator {
        private final float mTension;
    
        public OvershootInterpolator() {
            mTension = 2.0f;
        }
    
        /**
         * @param tension Amount of overshoot. When tension equals 0.0f, there is
         *                no overshoot and the interpolator becomes a simple
         *                deceleration interpolator.
         */
        public OvershootInterpolator(float tension) {
            mTension = tension;
        }
    
        public OvershootInterpolator(Context context, AttributeSet attrs) {
            TypedArray a = context.obtainStyledAttributes(attrs,
                    com.android.internal.R.styleable.OvershootInterpolator);
    
            mTension =
                    a.getFloat(com.android.internal.R.styleable.OvershootInterpolator_tension, 2.0f);
    
            a.recycle();
        }
    
        public float getInterpolation(float t) {
            // _o(t) = t * t * ((tension + 1) * t + tension)
            // o(t) = _o(t - 1) + 1
            t -= 1.0f;
            return t * t * ((mTension + 1) * t + mTension) + 1.0f;
        }
    }
    复制代码

    项目链接:

      https://github.com/mengdd/HelloInterpolator.git

  • 相关阅读:
    js的this几种用法
    JS 事件绑定的几种方式 小笔记
    rem和em和px vh vw和% 移动端长度单位
    js 判断字符串中是否有某字符串
    angular2中的DOM操作之如何使input获取焦点
    angular2模板绑定样式
    论vw单位的实用性
    谷歌浏览器关闭同源策略方法
    video字幕无法显示,video视频在google中无法控制快进
    video视频铺满
  • 原文地址:https://www.cnblogs.com/tonny-li/p/4174437.html
Copyright © 2011-2022 走看看