时间版运动框架

 1 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN"
 2 "http://www.w3.org/TR/html4/strict.dtd">
 3
 4 <html xmlns="http://www.w3.org/1999/xhtml" lang="en">
 5     <head>
 6         <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
 7         <title>2.用原生js写时间版的运动框架</title>
 8         <meta name="author" content="Administrator" />
 9     <style>
10             *{margin:0;padding:0}
11             #div1{width:100px;height:100px;position:absolute;background:red;left:200px;top:200px;}
12             #line{width:1px;height:500px;background:#000000;position:absolute;left:500px;}
13         </style>
14         <!-- Date: 2014-12-15 -->
15
16         <script src="../../tween.js"></script>
17         <script>
18             window.onload=function(){
19                  var oDiv1=getById(‘div1‘);
20                  oDiv1.onmouseover=function(){
21                          hcMove(oDiv1,{‘width‘:200,‘height‘:200,‘left‘:150,‘top‘:150},2000,‘linear‘)
22                  }
23
24                  oDiv1.onmouseout=function(){hcMove(oDiv1,{‘width‘:100,‘height‘:100,‘left‘:200,‘top‘:200},2000,‘linear‘)
25                  }
26             }
27             function hcMove(obj,json,times,fx,fn){
28                  var iCur={}; //获取初始值 b
29                  iCur[attr] = 0; //初始化 所有值为0
30
31                  for(var attr in json) //区分透明度和其他属性的初始值的区别
32                  {
33                      if(attr == ‘opacity‘){
34                           iCur[attr] = Math.round(getStyle( obj,attr )*100)
35
36                      }else{
37                          iCur[attr] = parseInt(getStyle(obj,attr))
38                      }
39                  }
40
41                  clearInterval( obj.timer );
42
43                  var oldTime=nowTime();
44
45                  obj.timer=setInterval(function(){
46                          var newTime=nowTime();
47
48                          // oldTime < newTime;
49                          // oldTime - newTime //负数 到负无穷
50
51                          var t1=oldTime - newTime + 2000;  //从2000开始减小 一直到负无穷
52
53                          Math.max( 0, t1) //t1先 大于 0  后小于0
54                          var t=2000-Math.max( 0, t1); //0 2000 //当前时间  ,所有属性的当前时间都一样
55
56                          for(var attr in json)
57                          {
58                               var value=Tween[fx](t,iCur[attr],json[attr]-iCur[attr],times); //当前位置,变化值
59                               if( attr == ‘opacity‘ ){
60                                   obj.style[attr] = value/100;
61                                   obj.style.filter = ‘alpha(opacity=‘+value+‘)‘
62                               }else{
63                                   obj.style[attr] = value +‘px‘;
64                               }
65                          }
66
67                          if( t==times ){
68                              clearInterval( obj.timer );
69                              fn && fn.call(obj)
70                          }
71
72                  },13)
73             }
74
75             function nowTime(){ return (new Date).getTime() }
76
77             function getStyle ( obj, attr ) { return obj.currentStyle?obj.currentStyle[attr] : getComputedStyle( obj )[attr]; }
78             /*getById()**/
79             function getById(id){ return document.getElementById(id) }
80
81
82
83         </script>
84     </head>
85     <body>
86         <div id="div1"></div>
87     </body>
88 </html>

tweens.js

  1 var Tween = {
  2     linear: function (t, b, c, d){  //匀速
  3         return c*t/d + b;
  4     },
  5     easeIn: function(t, b, c, d){  //加速曲线
  6         return c*(t/=d)*t + b;
  7     },
  8     easeOut: function(t, b, c, d){  //减速曲线
  9         return -c *(t/=d)*(t-2) + b;
 10     },
 11     easeBoth: function(t, b, c, d){  //加速减速曲线
 12         if ((t/=d/2) < 1) {
 13             return c/2*t*t + b;
 14         }
 15         return -c/2 * ((--t)*(t-2) - 1) + b;
 16     },
 17     easeInStrong: function(t, b, c, d){  //加加速曲线
 18         return c*(t/=d)*t*t*t + b;
 19     },
 20     easeOutStrong: function(t, b, c, d){  //减减速曲线
 21         return -c * ((t=t/d-1)*t*t*t - 1) + b;
 22     },
 23     easeBothStrong: function(t, b, c, d){  //加加速减减速曲线
 24         if ((t/=d/2) < 1) {
 25             return c/2*t*t*t*t + b;
 26         }
 27         return -c/2 * ((t-=2)*t*t*t - 2) + b;
 28     },
 29     elasticIn: function(t, b, c, d, a, p){  //正弦衰减曲线(弹动渐入)
 30         if (t === 0) {
 31             return b;
 32         }
 33         if ( (t /= d) == 1 ) {
 34             return b+c;
 35         }
 36         if (!p) {
 37             p=d*0.3;
 38         }
 39         if (!a || a < Math.abs(c)) {
 40             a = c;
 41             var s = p/4;
 42         } else {
 43             var s = p/(2*Math.PI) * Math.asin (c/a);
 44         }
 45         return -(a*Math.pow(2,10*(t-=1)) * Math.sin( (t*d-s)*(2*Math.PI)/p )) + b;
 46     },
 47     elasticOut: function(t, b, c, d, a, p){    //正弦增强曲线(弹动渐出)
 48         if (t === 0) {
 49             return b;
 50         }
 51         if ( (t /= d) == 1 ) {
 52             return b+c;
 53         }
 54         if (!p) {
 55             p=d*0.3;
 56         }
 57         if (!a || a < Math.abs(c)) {
 58             a = c;
 59             var s = p / 4;
 60         } else {
 61             var s = p/(2*Math.PI) * Math.asin (c/a);
 62         }
 63         return a*Math.pow(2,-10*t) * Math.sin( (t*d-s)*(2*Math.PI)/p ) + c + b;
 64     },
 65     elasticBoth: function(t, b, c, d, a, p){
 66         if (t === 0) {
 67             return b;
 68         }
 69         if ( (t /= d/2) == 2 ) {
 70             return b+c;
 71         }
 72         if (!p) {
 73             p = d*(0.3*1.5);
 74         }
 75         if ( !a || a < Math.abs(c) ) {
 76             a = c;
 77             var s = p/4;
 78         }
 79         else {
 80             var s = p/(2*Math.PI) * Math.asin (c/a);
 81         }
 82         if (t < 1) {
 83             return - 0.5*(a*Math.pow(2,10*(t-=1)) *
 84                     Math.sin( (t*d-s)*(2*Math.PI)/p )) + b;
 85         }
 86         return a*Math.pow(2,-10*(t-=1)) *
 87                 Math.sin( (t*d-s)*(2*Math.PI)/p )*0.5 + c + b;
 88     },
 89     backIn: function(t, b, c, d, s){     //回退加速(回退渐入)
 90         if (typeof s == ‘undefined‘) {
 91            s = 1.70158;
 92         }
 93         return c*(t/=d)*t*((s+1)*t - s) + b;
 94     },
 95     backOut: function(t, b, c, d, s){
 96         if (typeof s == ‘undefined‘) {
 97             s = 3.70158;  //回缩的距离
 98         }
 99         return c*((t=t/d-1)*t*((s+1)*t + s) + 1) + b;
100     },
101     backBoth: function(t, b, c, d, s){
102         if (typeof s == ‘undefined‘) {
103             s = 1.70158;
104         }
105         if ((t /= d/2 ) < 1) {
106             return c/2*(t*t*(((s*=(1.525))+1)*t - s)) + b;
107         }
108         return c/2*((t-=2)*t*(((s*=(1.525))+1)*t + s) + 2) + b;
109     },
110     bounceIn: function(t, b, c, d){    //弹球减振(弹球渐出)
111         return c - Tween[‘bounceOut‘](d-t, 0, c, d) + b;
112     },
113     bounceOut: function(t, b, c, d){
114         if ((t/=d) < (1/2.75)) {
115             return c*(7.5625*t*t) + b;
116         } else if (t < (2/2.75)) {
117             return c*(7.5625*(t-=(1.5/2.75))*t + 0.75) + b;
118         } else if (t < (2.5/2.75)) {
119             return c*(7.5625*(t-=(2.25/2.75))*t + 0.9375) + b;
120         }
121         return c*(7.5625*(t-=(2.625/2.75))*t + 0.984375) + b;
122     },
123     bounceBoth: function(t, b, c, d){
124         if (t < d/2) {
125             return Tween[‘bounceIn‘](t*2, 0, c, d) * 0.5 + b;
126         }
127         return Tween[‘bounceOut‘](t*2-d, 0, c, d) * 0.5 + c*0.5 + b;
128     }
129 }
时间: 2024-11-02 14:16:39

时间版运动框架的相关文章

时间版 运动框架

<!DOCTYPE html><html> <head> <meta charset="UTF-8"> <title>时间版运动框架</title> <style type="text/css"> *{margin: 0px;padding: 0px;} #box{ width: 100px; height: 100px; background: red; margin-left:5

javascript中的时间版运动

前面的话 速度版JS运动是指以速度为参照,随着路程的变化,时间随之变化:而时间版JS运动是指以时间为参照,随着路程的变化,速度随着变化.相较而言,时间版JS运动更为常用.JQ的animate就是时间版运动.本文将详细介绍时间版JS运动 速度版运动 为何速度版JS更容易理解呢?这要归功于定时器setInterval了.最容易想到的运行形式如下所示 setInterval(function(){ s = s + step },30) 每30ms,路程增加step,实际上就决定了以速度为参照.而ste

【原生JS组件】javascript 运动框架

大家都知道JQuerry有animate方法来给DOM元素进行运动,CSS3中也有transition.transform来进行运动.而使用原生的Javascript来控制元素运动,需要写很多运动的细节以及兼容. 然而,当你的BOSS不让你使用庞大的JQ框架,而且你开发的产品也需要在一些不兼容CSS3的浏览器运行的时候,你是否觉得每次都要开个定时器来琢磨运动该怎么进行,是件很费力的事情呢? 那么福利来了,笔者最近总结了两个常用的运动框架,并将其写成组件, 只要按照下面的方法调用,即可方便使用.

【repost】JavaScript运动框架之速度时间版本

一.JavaScript运动框架之速度版 1.1 运动框架的实现思路 运动,其实就是在一段时间内改变 left . right . width . height . opactiy 的值,到达目的地之后停止 位移 top,left 折叠 width,height 淡入淡出 opacity 时间有关系 setInterval setTimeout 用javascript直接获取行间样式很容易,但如果要获取非行间样式那我们只能借助函数了.我这里编写了一个名为getStyle的函数,专门处理取非行间的

js运动框架逐渐递进版

运动,其实就是在一段时间内改变left.right.width.height.opactiy的值,到达目的地之后停止. 现在按照以下步骤来进行我们的运动框架的封装: 匀速运动. 缓冲运动. 多物体运动. 任意值变化. 链式运动. 同时运动 (第一部分):匀速运动 运动基础 思考:如何让div动起来?如下: 设置元素为绝对定位,只有绝对定位后,left,top等值才生效. 定时器的使用(动态改变值),这里使用setInterval()每隔指定的时间执行代码. 计时器setInterval(函数,交

原生JS封装运动框架

昨天我们说了一下原生JS中常用的兼容性写法,今天我们来说一下运动框架. 正常情况下我们要写一个运动的效果会用到tween.js这么一个插件,这个东西不是一般人写出来的,因为里面涉及的运动效果都是经过一堆数学的函数运算出来的,我们平常人是写不出来的,所有我们就自己封装一个运动框架,有什么问题改起来也方便,下面我们就开始封装. 首先,我们先写一个div,设置一些简单的样式,我们就拿这个div举例子,如下代码: #div{ width: 100px; height: 100px; background

js运动框架完成块的宽高透明度及颜色的渐变

了解了运动框架完成块元素的宽高和透明度的变化的原理,我想着写一个颜色的变化来练习一下,不想写了很长时间才写出来,跟各位分享一下. 颜色的变化是通过三元素渐变的方式完成的,通过构造json,使当前的颜色与目标颜色进行对比,实现渐变的过程. 代码如下: 1 <!DOCTYPE html> 2 <html> 3 <head lang="en"> 4 <meta charset="UTF-8"> 5 <title>

简易运动框架

简易的运动框架可以用来控制长宽高.位置.透明度,结合定时器可以实现简单的动画. 其中最主要也是最基础的就是获得元素的属性,我们先来看一下给元素添加样式的三种方法:行内样式.嵌入式样式.外链样式表 1 <!DOCTYPE html> 2 <html lang="en"> 3 <head> 4 <meta charset="UTF-8"> 5 <title>Document</title> 6 &l

转 JavaScript 运动框架 Step by step

1,运动原理 Js运动,本质来说,就是让 web 上 DOM 元素动起来.而想要 DOM 动起来,改变其自身的位置属性,比如高宽,左边距,上边距,透明度等.动画的原理就是把不同状态的物体,串成连续的样子,就像一本书,画了几个小人,然后 一翻书,就看见小人在动.js动画也一样.不同状态的DOM,用定时器控制,就能得到动画效果. [javascript] view plain copy window.onload = function(){ var oBtn = document.getElemen