当前位置： 移动技术网 > IT编程>开发语言>JavaScript > tween.js缓动补间动画算法示例

tween.js缓动补间动画算法示例

2018年02月17日  | 移动技术网IT编程  | 我要评论

一、理解tween.js

如果看到上面的已经理解了,可以跳过下面的部分.下面为对tween.js的解释 下面就介绍如何使用这个tween了，首先b、c、d三个参数（即初始值，变化量，持续时间）在缓动开始前，是需要先确定好的。 首先引入一个概念就补间动画 flash做动画时会用到tween类，利用它可以做很多动画效果，例如缓动、弹簧等等。 tween.js在flash中可以解释为补间动画. 那么问题来了,什么是补间动画呢?

相信学过flash的都知道补间动画是flash主要的非常重要的表现手段之一.补间动画有动作补间动画与形状补间动画两种,但是在js中却不需要了解这么多. 好了,废话不多说,先看看百度百科关于补间动画给出的定义: 补间动画：做flash动画时，在两个关键帧中间需要做“补间动画”，才能实现图画的运动； 插入补间动画后两个关键帧之间的插补帧是由计算机自动运算而得到的

那么什么是关键帧呢? 举个栗子: 先科普一下,平常所看的电影,动画都是24帧的,24帧为一秒.在人眼可以捕捉的范围内.可以想象两个点之间有有22个点,形成一条直线或者曲线.而每一个点就代表一帧,帧——就是动画中最小单位的单幅影像画面,而单幅影像画面就可以看做是一个对象(一切皆对象,除去值类型)了.而这条线就代表对象的运动轨迹.

二、四个参数

  1. t: current time-->代表第一个点，也就是第一帧，也就是一个动画开始的地方。
  2. b: beginning value-->代表初始值，也就是开始量，我们看电影或者动画一般都不会看序幕把，那么跳过开头部分，选择第一帧和最后一帧之间你要开始看位置，而此位置就是初始值。
  3. c: change in value-->代表的就是最后一帧减去初始值就是变化量，
  4. d: duration-->代表最后一帧,1s的结束,也是动画的结束。

tween.js的使用 1.下载 2.引入 3.使用tween.js语法

tween.缓动函数名.缓动效果名(t,b,c,d);

注意:当开始步数增加到与结束步数相等时,整个运动结束. 注注意:只有当t增加到与d相等时才会结束运动;如果不等,运动不会停止.

三、tween文件代码

/*
 * tween.js
 * t: current time（当前时间）；
 * b: beginning value（初始值）；
 * c: change in value（变化量）；
 * d: duration（持续时间）。
*/
var tween = {
  linear: function(t, b, c, d) { //匀速
    return c * t / d + b; 
  },
  quad: { //二次方缓动效果
    easein: function(t, b, c, d) {
      return c * (t /= d) * t + b;
    },
    easeout: function(t, b, c, d) {
      return -c *(t /= d)*(t-2) + b;
    },
    easeinout: function(t, b, c, d) {
      if ((t /= d / 2) < 1) return c / 2 * t * t + b;
      return -c / 2 * ((--t) * (t-2) - 1) + b;
    }
  },
  cubic: { //三次方缓动效果
    easein: function(t, b, c, d) {
      return c * (t /= d) * t * t + b;
    },
    easeout: function(t, b, c, d) {
      return c * ((t = t/d - 1) * t * t + 1) + b;
    },
    easeinout: function(t, b, c, d) {
      if ((t /= d / 2) < 1) return c / 2 * t * t*t + b;
      return c / 2*((t -= 2) * t * t + 2) + b;
    }
  },
  quart: { //四次方缓动效果
    easein: function(t, b, c, d) {
      return c * (t /= d) * t * t*t + b;
    },
    easeout: function(t, b, c, d) {
      return -c * ((t = t/d - 1) * t * t*t - 1) + b;
    },
    easeinout: function(t, b, c, d) {
      if ((t /= d / 2) < 1) return c / 2 * t * t * t * t + b;
      return -c / 2 * ((t -= 2) * t * t*t - 2) + b;
    }
  },
  quint: { //五次方缓动效果
    easein: function(t, b, c, d) {
      return c * (t /= d) * t * t * t * t + b;
    },
    easeout: function(t, b, c, d) {
      return c * ((t = t/d - 1) * t * t * t * t + 1) + b;
    },
    easeinout: function(t, b, c, d) {
      if ((t /= d / 2) < 1) return c / 2 * t * t * t * t * t + b;
      return c / 2*((t -= 2) * t * t * t * t + 2) + b;
    }
  },
  sine: { //正弦缓动效果
    easein: function(t, b, c, d) {
      return -c * math.cos(t/d * (math.pi/2)) + c + b;
    },
    easeout: function(t, b, c, d) {
      return c * math.sin(t/d * (math.pi/2)) + b;
    },
    easeinout: function(t, b, c, d) {
      return -c / 2 * (math.cos(math.pi * t/d) - 1) + b;
    }
  },
  expo: { //指数缓动效果
    easein: function(t, b, c, d) {
      return (t==0) ? b : c * math.pow(2, 10 * (t/d - 1)) + b;
    },
    easeout: function(t, b, c, d) {
      return (t==d) ? b + c : c * (-math.pow(2, -10 * t/d) + 1) + b;
    },
    easeinout: function(t, b, c, d) {
      if (t==0) return b;
      if (t==d) return b+c;
      if ((t /= d / 2) < 1) return c / 2 * math.pow(2, 10 * (t - 1)) + b;
      return c / 2 * (-math.pow(2, -10 * --t) + 2) + b;
    }
  },
  circ: { //圆形缓动函数
    easein: function(t, b, c, d) {
      return -c * (math.sqrt(1 - (t /= d) * t) - 1) + b;
    },
    easeout: function(t, b, c, d) {
      return c * math.sqrt(1 - (t = t/d - 1) * t) + b;
    },
    easeinout: function(t, b, c, d) {
      if ((t /= d / 2) < 1) return -c / 2 * (math.sqrt(1 - t * t) - 1) + b;
      return c / 2 * (math.sqrt(1 - (t -= 2) * t) + 1) + b;
    }
  },
  elastic: { //指数衰减正弦曲线缓动函数
    easein: function(t, b, c, d, a, p) { //加速
      var s;
      if (t==0) return b;
      if ((t /= d) == 1) return b + c;
      if (typeof p == "undefined") p = d * .3;
      if (!a || a < math.abs(c)) {
        s = p / 4;
        a = c;
      } else {
        s = p / (2 * math.pi) * math.asin(c / a);
      }
      return -(a * math.pow(2, 10 * (t -= 1)) * math.sin((t * d - s) * (2 * math.pi) / p)) + b;
    },
    easeout: function(t, b, c, d, a, p) { //减速
      var s;
      if (t==0) return b;
      if ((t /= d) == 1) return b + c;
      if (typeof p == "undefined") p = d * .3;
      if (!a || a < math.abs(c)) {
        a = c; 
        s = p / 4;
      } else {
        s = p/(2*math.pi) * math.asin(c/a);
      }
      return (a * math.pow(2, -10 * t) * math.sin((t * d - s) * (2 * math.pi) / p) + c + b);
    },
    easeinout: function(t, b, c, d, a, p) { //先加速后减速
      var s;
      if (t==0) return b;
      if ((t /= d / 2) == 2) return b+c;
      if (typeof p == "undefined") p = d * (.3 * 1.5);
      if (!a || a < math.abs(c)) {
        a = c; 
        s = p / 4;
      } else {
        s = p / (2 *math.pi) * math.asin(c / a);
      }
      if (t < 1) return -.5 * (a * math.pow(2, 10* (t -=1 )) * math.sin((t * d - s) * (2 * math.pi) / p)) + b;
      return a * math.pow(2, -10 * (t -= 1)) * math.sin((t * d - s) * (2 * math.pi) / p ) * .5 + c + b;
    }
  },
  back: { //超过范围的三次方的缓动函数
    easein: function(t, b, c, d, s) {
      if (typeof s == "undefined") s = 1.70158;
      return c * (t /= d) * t * ((s + 1) * t - s) + b;
    },
    easeout: function(t, b, c, d, s) {
      if (typeof s == "undefined") s = 1.70158;
      return c * ((t = t/d - 1) * t * ((s + 1) * t + s) + 1) + b;
    },
    easeinout: function(t, b, c, d, s) {
      if (typeof s == "undefined") s = 1.70158; 
      if ((t /= d / 2) < 1) return c / 2 * (t * t * (((s *= (1.525)) + 1) * t - s)) + b;
      return c / 2*((t -= 2) * t * (((s *= (1.525)) + 1) * t + s) + 2) + b;
    }
  },
  bounce: { //指数衰减的反弹曲线缓动函数
    easein: function(t, b, c, d) {
      return c - tween.bounce.easeout(d-t, 0, c, d) + b;
    },
    easeout: function(t, b, c, d) {
      if ((t /= d) < (1 / 2.75)) {
        return c * (7.5625 * t * t) + b;
      } else if (t < (2 / 2.75)) {
        return c * (7.5625 * (t -= (1.5 / 2.75)) * t + .75) + b;
      } else if (t < (2.5 / 2.75)) {
        return c * (7.5625 * (t -= (2.25 / 2.75)) * t + .9375) + b;
      } else {
        return c * (7.5625 * (t -= (2.625 / 2.75)) * t + .984375) + b;
      }
    },
    easeinout: function(t, b, c, d) {
      if (t < d / 2) {
        return tween.bounce.easein(t * 2, 0, c, d) * .5 + b;
      } else {
        return tween.bounce.easeout(t * 2 - d, 0, c, d) * .5 + c * .5 + b;
      }
    }
  }
}
math.tween = tween;

四、举个栗子

<!doctype html>
<html>

  <head>
    <meta charset="utf-8">
    <title></title>
    <script src="https://cdn.jsdelivr.net/npm/vue"></script>
    <script src="tween/tween.js"></script>
    <style>
      *{margin: 0;padding: 0;}
      .out{width: 800px;height: 500px;background: #e5e5e5;position: relative;padding: 20px;text-align: center;}
      .inner{width: 50px;height: 50px;border-radius: 50%;background: #ff0000; position: absolute;left: 50px;top: 50px;}
    </style>
  </head>

  <body>
    <div id="app" class="out">
      <div class="inner" id="ball"></div>
      <button id="start" @click="start()">start</button>
    </div>
  </body>
  <script type="text/javascript">
    var app = new vue({
      el: '#app',
      data: {
        t: 0,
        b: 50,
        c: 500,
        d: 1500,
      },
      methods:{
        start(){
          var t = this.t;
          const b = this.b;
          const c = this.c;
          const d = this.d;
          const setint = setinterval(()=>{
            t++;
            console.log(t)
            if(t==300){clearinterval(setint)}
            console.log(t);
            const ballleft = tween.linear(t,b,c,d)+"px";
            ball.style.left = ballleft;
          },20)
        }
      }
    })
  </script>
</html>

五、个人体会

tween的优势在于tween实现效果是依据算法，不是某种语言的语法，因此可以运用的地方很广泛，一次学习终身受益。

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持移动技术网。

您可能感兴趣的文章:

如对本文有疑问， 点击进行留言回复！！

相关文章:

验证码：
最近更新的文章
大家感兴趣的文章
移动技术网