tween.js 用户指南 - 与 Three.js 配合使用的补间动画库
tween.js 用户指南 - 与 Three.js 配合使用的补间动画库
太阳火神的美丽人生 (http://blog.csdn.net/opengl_es)
本文遵循“署名-非商业用途-保持一致”创作公用协议
转载请保留此句：太阳火神的美丽人生 - 本博客专注于 敏捷开发及移动和物联设备研究：iOS、Android、Html5、Arduino、pcDuino，否则，出自本博客的文章拒绝转载或再转载，谢谢合作。
Learning Three.js - Tween.js for Smooth Animation
tween.js 用户指南
tween.js user guide
注意，这是一个进行中的工作，请原谅其中的不足。无论何时，你看到标记为 TODO 的内容，就说明它是还未做的部分。如果你有哪些东西不清楚或缺少细节内容，请提交一个问题，以帮助使这个指南变得更好。或者如果你觉得你也可以提供帮助的话，你可以随意提交你自已的说明或改进。
NOTE this is a work in progress, please excuse the gaps. Wherever you see something marked as TODO, it's not done yet. If you something is unclear or missing details, please file an issue and help make this guide better. Or feel free to submit clarifications or improvements of your own if you feel you can help too!
什么是补间动画？他们如何工作？为什么你想要使用它们？
What is a tween? How do they work? Why do you want to use them?
A tween (from in-between) is a concept that allows you to change the values of the properties of an object in a smooth way. You just tell it which properties you want to change, which final values should they have when the tween finishes running, and how long should this take, and the tweening engine will take care of finding the intermediate values from the starting to the ending point. For example, suppose you have a position object with x and y coordinates:
var position = { x: 100, y: 0 }
If you wanted to change the x value from 100 to 200, you'd do this:
// Create a tween for position first
var tween = new TWEEN.Tween(position);// Then tell the tween we want to animate the x property over 1000 milliseconds
tween.to({ x: 200 }, 1000);
Actually this won't do anything yet. The tween has been created but it's not active. You need to start it:
// And set it to start tween.start();
Finally in order to run as smoothly as possible you should call the TWEEN.update function in the same main loop you're using for animating. This generally looks like this:
animate();function animate() {requestAnimationFrame(animate);// [...]TWEEN.update();// [...]
}
This will take care of updating all active tweens; after 1 second (i.e. 1000 milliseconds) position.x will be 200.
But unless you print the value of x to the console, you can't see its value changing. You might want to use the onUpdate callback:
tween.onUpdate(function() {console.log(this.x);
});
This function will be called each time the tween is updated; how often this happens depends on many factors--how fast (and how busy!) your computer or device is, for example.
So far we've only used tweens to print values to the console, but you could use it for things such as animating positions of three.js objects:
var tween = new TWEEN.Tween(cube.position);.to({ x: 100, y: 100, z: 100 }, 10000).start();animate();function animate() {requestAnimationFrame(animate);TWEEN.update();threeRenderer.render(scene, camera);
}
In this case, because the three.js renderer will look at the object's position before rendering, you don't need to use an explicitonUpdate callback.
You might have noticed something different here too: we're chaining the tween function calls! Each tween function returns the tween instance, so you can rewrite the following code:
var tween = new TWEEN.Tween(position);
tween.to({ x: 200 }, 1000);
tween.start();
into this
var tween = new TWEEN.Tween(position).to({ x: 200 }, 1000).start();
You'll see this a lot in the examples, so it's good to be familiar with it! Check 04-simplest for a working example.
使用 tween.js 的动画
Animating with tween.js
Tween.js doesn't run by itself. You need to tell it when to run, by explicitly calling the update method. The recommended method is to do this inside your main animation loop, which should be called with requestAnimationFrame for getting the best graphics performance:
We've seen this example before:
animate();function animate() {requestAnimationFrame(animate);// [...]TWEEN.update();// [...]
}
If called without parameters, update will determine the current time in order to find out how long has it been since the last time it ran.
However you can also pass an explicit time parameter to update. Thus,
TWEEN.update(100);
means "update with time = 100 milliseconds". You can use this to make sure that all the time-dependent functions in your code are using the very same time value. For example suppose you've got a player and want to run tweens in sync. Your animate code could look like this:
var currentTime = player.currentTime; TWEEN.update(currentTime);
We use explicit time values for the unit tests. You can have a look at TestTweens to see how we call TWEEN.update() with different values in order to simulate time passing.
控制一个补间动画
Controlling a tween
启动和停止
start and stop
start
So far we've learnt about the Tween.start method, but there are more methods that control individual tweens. Probably the most important one is the start counterpart: stop. If you want to cancel a tween, just call this method over an individual tween:
tween.stop();
Stopping a tween that was never started or that has already been stopped has no effect. No errors are thrown either.
The start method also accepts a time parameter. If you use it, the tween won't start until that particular moment in time; otherwise it will start as soon as possible (i.e. on the next call to TWEEN.update).
更新
update
update
Individual tweens also have an update method---this is in fact called by TWEEN.update. You generally don't need to call this directly, but might be useful if you're doing crazy hacks.
链接
chain
Things get more interesting when you sequence different tweens in order, i.e. setup one tween to start once a previous one has finished. We call this chaining tweens, and it's done with the chain method. Thus, to make tweenB start after tweenA finishes:
tweenA.chain(tweenB);
Or, for an infinite chain, set tweenA to start once tweenB finishes:
tweenA.chain(tweenB); tweenB.chain(tweenA);
Check Hello world to see an example of these infinite chains.
重复
repeat
重复
If you wanted a tween to repeat forever you could chain it to itself, but a better way is to use the repeat method. It accepts a parameter that describes how many repetitions you want:
tween.repeat(10); // repeats 10 times and stops tween.repeat(Infinity); // repeats forever
Check the Repeat example.
摇摇乐
yoyo
This function only has effect if used along with repeat. When active, the behaviour of the tween will be like a yoyo, i.e. it will bounce to and from the start and end values, instead of just repeating the same sequence from the beginning.
延迟
delay
delay
More complex arrangements might require delaying a tween before it actually starts running. You can do that using the delaymethod:
tween.delay(1000); tween.start();
will start executing 1 second after the start method has been called.
控制所有的补间动画
Controlling all the tweens
The following methods are found in the TWEEN global object, and you generally won't need to use most of them, except for update.
TWEEN.update(time)
We've already talked about this method. It is used to update all the active tweens.
If time is not specified, it will use the current time.
TWEEN.getAll and TWEEN.removeAll
Used to get a reference to the active tweens array and to remove all of them from the array with just one call, respectively.
TWEEN.add(tween) and TWEEN.remove(tween)
Used to add a tween to the list of active tweens, or to remove an specific one from the list, respectively.
These methods are usually used internally only, but are exposed just in case you want to do something funny.
修改 easing 功能（AKA make it councy）
Changing the easing function (AKA make it bouncy)
Tween.js will perform the interpolation between values (i.e. the easing) in a linear manner, so the change will be directly proportional to the elapsed time. This is predictable but also quite uninteresting visually wise. Worry not--this behaviour can be easily changed using the easing method. For example:
tween.easing(TWEEN.Easing.Quadratic.In);
This will result in the tween slowly starting to change towards the final value, accelerating towards the middle, and then quickly reaching its final value. In contrast, TWEEN.Easing.Quadratic.Out would start changing quickly towards the value, but then slow down as it approaches the final value.
可用的 easing 函数
Available easing functions: TWEEN.Easing
There are a few existing easing functions provided with tween.js. They are grouped by the type of equation they represent: Linear, Quadratic, Cubic, Quartic, Quintic, Sinusoidal, Exponential, Circular, Elastic, Back and Bounce, and then by the easing type: In, Out and InOut.
Probably the names won't be saying anything to you unless you're familiar with these concepts already, so it is probably the time to check the Graphs example, which graphs all the curves in one page so you can compare how they look at a glance.
Credit where credit is due: these functions are derived from the original set of equations that Robert Penner graciously made available as free software a few years ago, but have been optimised to play nicely with JavaScript.
使用自定义的 easing 函数
Using a custom easing function
Not only can you use any of the existing functions, but you can also provide your own, as long as it follows a couple of conventions:
- it must accept one parameter:
k: the easing progress, or how far along the duration of the tween we are. Allowed values are in the range [0, 1].
- it must return a value based on the input parameters.
The easing function is only called once per tween on each update, no matter how many properties are to be changed. The result is then used with the initial value and the difference (the deltas) between this and the final values, as in this pseudocode:
easedElapsed = easing(k);
for each property:newPropertyValue = initialPropertyValue + propertyDelta * easedElapsed;
For the performance obsessed people out there: the deltas are calculated only when start() is called on a tween.
So let's suppose you wanted to use a custom easing function that eased the values but appplied a Math.floor to the output, so only the integer part would be returned, resulting in a sort of step-ladder output:
function tenStepEasing(k) {return Math.floor(k * 10) / 10;
}
And you could use it in a tween by simply calling its easing method, as we've seen before:
tween.easing(tenStepEasing);
Check the graphs for custom easing functions example to see this in action (and also some metaprogramming for generating step functions).
回调
Callbacks
Another powerful feature is to be able to run your own functions at specific times in each tween's life cycle. This is usually required when changing properties is not enough.
For example, suppose you're trying to animate some object whose properties can't be accessed directly but require you to call a setter instead. You can use an update callback to read the new updated values and then manually call the setters:
var trickyObjTween = new TWEEN.Tween({propertyA: trickyObj.getPropertyA(),propertyB: trickyObj.getPropertyB()
}).to({ propertyA: 100, propertyB: 200 }).onUpdate(function() {this.setA( this.propertyA );this.setB( this.propertyB );});
Or imagine you want to ensure the values of an object are in an specific state each time the tween is started. You'll assign a startcallback:
var tween = new TWEEN.Tween(obj).to({ x: 100 }).onStart(function() {this.x = 0;});
The scope for each callback is the tweened object.
启动时回调
onStart
Executed right before the tween starts-i.e. before the deltas are calculated. This is the place to reset values in order to have the tween always start from the same point, for example.
停止时回调
onStop
Executed when a tween is explicitly stopped (not when it is completed normally), and before stopping any possible chained tween.
更新时回调
onUpdate
Executed each time the tween is updated, after the values have been actually updated.
完成时回调
onComplete
Executed when a tween is finished normally (i.e. not stopped).
高级补间动画
Advanced tweening
相对值
Relative values
You can also use relative values when using the to method. When the tween is started, Tween.js will read the current property values and apply the relative values to find out the new final values. But you need to use quotes or the values will be taken as absolute. Let's see this with an example:
// This will make the `x` property be 100, always
var absoluteTween = new TWEEN.Tween(absoluteObj).to({ x: 100 });// Suppose absoluteObj.x is 0 now
absoluteTween.start(); // Makes x go to 100// Suppose absoluteObj.x is -100 now
absoluteTween.start(); // Makes x go to 100// In contrast...// This will make the `x` property be 100 units more,
// relative to the actual value when it starts
var relativeTween = new TWEEN.Tween(relativeObj).to({ x: "+100" });// Suppose relativeObj.x is 0 now
relativeTween.start(); // Makes x go to 0 +100 = 100// Suppose relativeObj.x is -100 now
relativeTween.start(); // Makes x go to -100 +100 = 0
Check 09_relative_values for an example.
补间到数组值
Tweening to arrays of values
In addition to tweening to an absolute or a relative value, you can also have Tween.js change properties across a series of values. To do this, you just need to specify an array of values instead of a single value for a property. For example:
var tween = new TWEEN.Tween(relativeObj).to({ x: [0, -100, 100] });
will make x go from its initial value to 0, -100 and 100.
The way these values are calculated is as follows:
- first the tween progress is calculated as usual
- the progress (from 0 to 1) is used as input for the interpolation function
- based on the progress and the array of values, an interpolated value is generated
For example, when the tween has just started (progress is 0), the interpolation function will return the first value in the array. When the tween is halfway, the interpolation function will return a value approximately in the middle of the array, and when the tween is at the end, the interpolation function will return the last value.
You can change the interpolation function with the interpolation method. For example:
tween.interpolation( TWEEN.Interpolation.Bezier );
The following values are available:
- TWEEN.Interpolation.Linear
- TWEEN.Interpolation.Bezier
- TWEEN.Interpolation.CatmullRom
The default is Linear.
Note that the interpolation function is global to all properties that are tweened with arrays in the same tween. You can't make property A change with an array and a Linear function, and property B with an array too and a Bezier function using the same tween; you should use two tween objects running over the same object but modifying different properties and using different interpolation functions.
Check 06_array_interpolation for an example.
获得最佳性能
Getting the best performance
While Tween.js tries to be performant on its own, nothing prevents you from using it in a way that is counterperformant. Here are some of the ways you can avoid slowing down your projects when using Tween.js (or when animating in the web, in general).
使用高性能的 CSS
Use performant CSS
When you try to animate the position of an element in the page, the easiest solution is to animate the top and left style properties, like this:
var element = document.getElementById('myElement');
var tween = new TWEEN.Tween({ top: 0, left: 0 }).to({ top: 100, left: 100 }, 1000).onUpdate(function() {element.style.top = this.top + 'px';element.style.left = this.left + 'px';});
but this is really inefficient because altering these properties forces the browser to recalculate the layout on each update, and this is a very costly operation. Instead of using these, you should use transform, which doesn't invalidate the layout and will also be hardware accelerated when possible, like this:
var element = document.getElementById('myElement');
var tween = new TWEEN.Tween({ top: 0, left: 0 }).to({ top: 100, left: 100 }, 1000).onUpdate(function() {element.style.transform = 'translate(' + this.left + 'px, ' + this.top + 'px);';});
If you want to read more about this, have a look at this article.
However, if your animation needs are that simple, it might be better to just use CSS animations or transitions, where applicable, so that the browser can optimise as much as possible. Tween.js is most useful when your animation needs involve complex arrangements, i.e. you need to sync several tweens together, have some start after one has finished, loop them a number of times, etc.
做好垃圾回收（别名 GC）
Be good to the Garbage collector (alias the GC)
If you use an onUpdate callback, you need to be very careful with what you put on it. This function will be called many times per second, so if you're doing costly operations on each update, you might block the main thread and cause horrible jank, or---if your operations involve memory allocations, you'll end up getting the garbage collector to run too often, and cause jank too. So just don't do either of those things. Keep your onUpdate callbacks very lightweight, and be sure to also use a memory profiler while you're developing.
超级补间动画
Crazy tweening
This is something you might not use often, but you can use the tweening equations outside of Tween.js. They're just functions, after all. So you could use them to calculate smooth curves as input data. For example, they're used to generate audio data in this experiment.
tween.js 用户指南 - 与 Three.js 配合使用的补间动画库相关推荐
- 详解TWEEN.JS 补间动画
tweenJS是一个简单的javascript补间动画库,支持数字,对象属性,CSS样式等的动态效果过渡,允许平滑的修改元素的属性值.告诉它需要改变的元素的开始值和结束值,并设置好过渡时间,补间动画将 ...
- 小程序集成Three.js，使用npm安装gsap动画库
0.视频演示 three.js集成gsap创建物体动画 gsap作为简单易用的补间动画库,获得开发者一致好评. 在小程序中,我们集成了Three.js第三方库,可以创建和加载模型及场景,但是做动画还是 ...
- html5怎么兼容js 插件,Modernizr.js入门指南(HTML5CSS3浏览器兼容插件)
HTML5 和 CSS3 的快速发展,给我们带来了极大的便利,比如从此再也不用花费大量的时间只是为了设计一个圆角的效果. 但是!我们不能像控制机器一样来控制所有的人都一夜之间升级到现代浏览器,因为那些 ...
- js svg语音波动动画_11 个非常受欢迎的 JavaScript 动画库，值得学习！
1.Three.js 超过46K的星星,这个流行的库提供了非常多的3D显示功能,以一种直观的方式使用 WebGL.这个库提供了. .CSS3D 和 WebGL渲染器,让我们在设备和浏览器之间创建丰富的 ...
- 《Node.js开发指南》书评汇总
刚查了下库存,发现订阅<Node.js开发指南>的读者大增,这是为什么呢?看了下近期本书在豆瓣的评论,口碑很好,现将豆瓣的书评汇总如下: ------------------------- ...
- 使用Nodejs创建基本的网站 Microblog--《Node.js开发指南》 1
使用Web框架 -- Express express -g 全局安装 express express_examplename install dependencies: $ cd express_e ...
- 《写给PHP开发者的Node.js学习指南》一2.2 预定义的PHP变量
本节书摘来自异步社区<写给PHP开发者的Node.js学习指南>一书中的第2章,第2.1节,作者[美]Daniel Howard,更多章节内容可以访问云栖社区"异步社区" ...
- 《Node.js开发指南》读书笔记
继续学学node.js.翻开书首先被惊到=.=:作者BYVoid是清华大学2010级本科--同样是2010级本科,我真是无语凝噎,大学浪费了好多时间.不过过去的已经过去了,接下来好好努力提高才好,加油 ...
- 《Three.js 开发指南》源码示例说明以及在线demo（原书第二版）附第三版的代码下载
<Three.js 开发指南>基于原书第二版 源码来自华章出版社官网随书源码,修改替换了其中不能跑的示例,保证每个demo都可以运行. 源码以及示例说明下载: git下载地址 huazha ...
最新文章
- 一文搞懂 CountDownLatch 用法和源码！
- C语言——四字节对齐（4对齐后是4, 5对齐后是8）
- 51Nod 1009 数字1的数量 数位dp
- tpc-c值大于46万_超过46万人参加了2018年慕尼黑啤酒节
- Save our Scrum作者访谈
- 深圳的90后，是如何渡过他们的周末的？
- php请求图片,PHP - 发送GET请求并获取图片作为回报
- node.js 处理 http 请求
- 20200627每日一句
- linux 下ssh下载文件命令
- 背包问题1:【SSL】1059.01背包问题——2021-03-10更
- MATLAB随机信号分析与处理
- java爬虫 抓取国家统计局：统计用区划代码和城乡划分代码（抓取省市区镇县办事处村委会数据）生成json
- 震旦打印机扫描显示服务器连接错误,震旦打印机Scan2me扫描失败（exchange邮箱）...
- 研究生能合作发表论文吗？
- Linux参考资料名称,Linux系统管理员必备参考资料下载汇总
- mysql lookup3,引用函数（三）：lookup
- 如何创建 Ubuntu 信息亭（kiosk）
- JEngine的使用-6-ClassBind之JUI
- 华为云教程（弹性云服务器ECS）