├── .gitignore ├── .npmignore ├── LICENSE.md ├── README.md ├── back-in-out.js ├── back-in.js ├── back-out.js ├── bounce-in-out.js ├── bounce-in.js ├── bounce-out.js ├── circ-in-out.js ├── circ-in.js ├── circ-out.js ├── cubic-in-out.js ├── cubic-in.js ├── cubic-out.js ├── elastic-in-out.js ├── elastic-in.js ├── elastic-out.js ├── expo-in-out.js ├── expo-in.js ├── expo-out.js ├── index.js ├── linear.js ├── package.json ├── quad-in-out.js ├── quad-in.js ├── quad-out.js ├── quart-in-out.js ├── quart-in.js ├── quart-out.js ├── quint-in-out.js ├── quint-in.js ├── quint-out.js ├── sine-in-out.js ├── sine-in.js ├── sine-out.js └── test.js /.gitignore: -------------------------------------------------------------------------------- 1 | bower_components 2 | node_modules 3 | *.log 4 | .DS_Store 5 | bundle.js 6 | -------------------------------------------------------------------------------- /.npmignore: -------------------------------------------------------------------------------- 1 | bower_components 2 | node_modules 3 | *.log 4 | .DS_Store 5 | bundle.js 6 | test 7 | test.js 8 | demo/ -------------------------------------------------------------------------------- /LICENSE.md: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | Copyright (c) 2014 Matt DesLauriers 3 | 4 | Permission is hereby granted, free of charge, to any person obtaining a copy 5 | of this software and associated documentation files (the "Software"), to deal 6 | in the Software without restriction, including without limitation the rights 7 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 8 | copies of the Software, and to permit persons to whom the Software is 9 | furnished to do so, subject to the following conditions: 10 | 11 | The above copyright notice and this permission notice shall be included in all 12 | copies or substantial portions of the Software. 13 | 14 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 15 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 16 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 17 | IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 18 | DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR 19 | OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE 20 | OR OTHER DEALINGS IN THE SOFTWARE. 21 | 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # eases 2 | 3 | [![stable](http://badges.github.io/stability-badges/dist/stable.svg)](http://github.com/badges/stability-badges) 4 | 5 | This is a grab-bag of [Robert Penner's easing equations](http://www.robertpenner.com/easing/), most of the code from [glsl-easings](https://www.npmjs.org/package/glsl-easings). Pull requests for optimizations are welcome. 6 | 7 | ```js 8 | //require all eases 9 | var quadIn = require('eases').quadIn 10 | 11 | //require only the single function 12 | var quadIn = require('eases/quad-in') 13 | ``` 14 | 15 | ## Usage 16 | 17 | [![NPM](https://nodei.co/npm/eases.png)](https://nodei.co/npm/eases/) 18 | 19 | Each easing has its own file which can be required individually. The entry point also exports all eases with camelCase, so `require('eases/expo-in-out')` becomes `require('eases').expoInOut`. 20 | 21 | Full list of eases: 22 | 23 | ```js 24 | require('eases/back-in-out') 25 | require('eases/back-in') 26 | require('eases/back-out') 27 | require('eases/bounce-in-out') 28 | require('eases/bounce-in') 29 | require('eases/bounce-out') 30 | require('eases/circ-in-out') 31 | require('eases/circ-in') 32 | require('eases/circ-out') 33 | require('eases/cubic-in-out') 34 | require('eases/cubic-in') 35 | require('eases/cubic-out') 36 | require('eases/elastic-in-out') 37 | require('eases/elastic-in') 38 | require('eases/elastic-out') 39 | require('eases/expo-in-out') 40 | require('eases/expo-in') 41 | require('eases/expo-out') 42 | require('eases/linear') 43 | require('eases/quad-in-out') 44 | require('eases/quad-in') 45 | require('eases/quad-out') 46 | require('eases/quart-in-out') 47 | require('eases/quart-in') 48 | require('eases/quart-out') 49 | require('eases/quint-in-out') 50 | require('eases/quint-in') 51 | require('eases/quint-out') 52 | require('eases/sine-in-out') 53 | require('eases/sine-in') 54 | require('eases/sine-out') 55 | ``` 56 | 57 | All easing functions only remap a time value, and all have the same signature. 58 | 59 | #### ```v = ease(t)``` 60 | 61 | Where `t` is typically a value between 0 and 1, and it returns a new float that has been eased. 62 | 63 | ## License 64 | 65 | MIT, see [LICENSE.md](http://github.com/mattdesl/eases/blob/master/LICENSE.md) for details. 66 | -------------------------------------------------------------------------------- /back-in-out.js: -------------------------------------------------------------------------------- 1 | function backInOut(t) { 2 | var s = 1.70158 * 1.525 3 | if ((t *= 2) < 1) 4 | return 0.5 * (t * t * ((s + 1) * t - s)) 5 | return 0.5 * ((t -= 2) * t * ((s + 1) * t + s) + 2) 6 | } 7 | 8 | module.exports = backInOut -------------------------------------------------------------------------------- /back-in.js: -------------------------------------------------------------------------------- 1 | function backIn(t) { 2 | var s = 1.70158 3 | return t * t * ((s + 1) * t - s) 4 | } 5 | 6 | module.exports = backIn -------------------------------------------------------------------------------- /back-out.js: -------------------------------------------------------------------------------- 1 | function backOut(t) { 2 | var s = 1.70158 3 | return --t * t * ((s + 1) * t + s) + 1 4 | } 5 | 6 | module.exports = backOut -------------------------------------------------------------------------------- /bounce-in-out.js: -------------------------------------------------------------------------------- 1 | var bounceOut = require('./bounce-out') 2 | 3 | function bounceInOut(t) { 4 | return t < 0.5 5 | ? 0.5 * (1.0 - bounceOut(1.0 - t * 2.0)) 6 | : 0.5 * bounceOut(t * 2.0 - 1.0) + 0.5 7 | } 8 | 9 | module.exports = bounceInOut -------------------------------------------------------------------------------- /bounce-in.js: -------------------------------------------------------------------------------- 1 | var bounceOut = require('./bounce-out') 2 | 3 | function bounceIn(t) { 4 | return 1.0 - bounceOut(1.0 - t) 5 | } 6 | 7 | module.exports = bounceIn -------------------------------------------------------------------------------- /bounce-out.js: -------------------------------------------------------------------------------- 1 | function bounceOut(t) { 2 | var a = 4.0 / 11.0 3 | var b = 8.0 / 11.0 4 | var c = 9.0 / 10.0 5 | 6 | var ca = 4356.0 / 361.0 7 | var cb = 35442.0 / 1805.0 8 | var cc = 16061.0 / 1805.0 9 | 10 | var t2 = t * t 11 | 12 | return t < a 13 | ? 7.5625 * t2 14 | : t < b 15 | ? 9.075 * t2 - 9.9 * t + 3.4 16 | : t < c 17 | ? ca * t2 - cb * t + cc 18 | : 10.8 * t * t - 20.52 * t + 10.72 19 | } 20 | 21 | module.exports = bounceOut -------------------------------------------------------------------------------- /circ-in-out.js: -------------------------------------------------------------------------------- 1 | function circInOut(t) { 2 | if ((t *= 2) < 1) return -0.5 * (Math.sqrt(1 - t * t) - 1) 3 | return 0.5 * (Math.sqrt(1 - (t -= 2) * t) + 1) 4 | } 5 | 6 | module.exports = circInOut -------------------------------------------------------------------------------- /circ-in.js: -------------------------------------------------------------------------------- 1 | function circIn(t) { 2 | return 1.0 - Math.sqrt(1.0 - t * t) 3 | } 4 | 5 | module.exports = circIn -------------------------------------------------------------------------------- /circ-out.js: -------------------------------------------------------------------------------- 1 | function circOut(t) { 2 | return Math.sqrt(1 - ( --t * t )) 3 | } 4 | 5 | module.exports = circOut -------------------------------------------------------------------------------- /cubic-in-out.js: -------------------------------------------------------------------------------- 1 | function cubicInOut(t) { 2 | return t < 0.5 3 | ? 4.0 * t * t * t 4 | : 0.5 * Math.pow(2.0 * t - 2.0, 3.0) + 1.0 5 | } 6 | 7 | module.exports = cubicInOut -------------------------------------------------------------------------------- /cubic-in.js: -------------------------------------------------------------------------------- 1 | function cubicIn(t) { 2 | return t * t * t 3 | } 4 | 5 | module.exports = cubicIn -------------------------------------------------------------------------------- /cubic-out.js: -------------------------------------------------------------------------------- 1 | function cubicOut(t) { 2 | var f = t - 1.0 3 | return f * f * f + 1.0 4 | } 5 | 6 | module.exports = cubicOut -------------------------------------------------------------------------------- /elastic-in-out.js: -------------------------------------------------------------------------------- 1 | function elasticInOut(t) { 2 | return t < 0.5 3 | ? 0.5 * Math.sin(+13.0 * Math.PI/2 * 2.0 * t) * Math.pow(2.0, 10.0 * (2.0 * t - 1.0)) 4 | : 0.5 * Math.sin(-13.0 * Math.PI/2 * ((2.0 * t - 1.0) + 1.0)) * Math.pow(2.0, -10.0 * (2.0 * t - 1.0)) + 1.0 5 | } 6 | 7 | module.exports = elasticInOut -------------------------------------------------------------------------------- /elastic-in.js: -------------------------------------------------------------------------------- 1 | function elasticIn(t) { 2 | return Math.sin(13.0 * t * Math.PI/2) * Math.pow(2.0, 10.0 * (t - 1.0)) 3 | } 4 | 5 | module.exports = elasticIn -------------------------------------------------------------------------------- /elastic-out.js: -------------------------------------------------------------------------------- 1 | function elasticOut(t) { 2 | return Math.sin(-13.0 * (t + 1.0) * Math.PI/2) * Math.pow(2.0, -10.0 * t) + 1.0 3 | } 4 | 5 | module.exports = elasticOut -------------------------------------------------------------------------------- /expo-in-out.js: -------------------------------------------------------------------------------- 1 | function expoInOut(t) { 2 | return (t === 0.0 || t === 1.0) 3 | ? t 4 | : t < 0.5 5 | ? +0.5 * Math.pow(2.0, (20.0 * t) - 10.0) 6 | : -0.5 * Math.pow(2.0, 10.0 - (t * 20.0)) + 1.0 7 | } 8 | 9 | module.exports = expoInOut -------------------------------------------------------------------------------- /expo-in.js: -------------------------------------------------------------------------------- 1 | function expoIn(t) { 2 | return t === 0.0 ? t : Math.pow(2.0, 10.0 * (t - 1.0)) 3 | } 4 | 5 | module.exports = expoIn -------------------------------------------------------------------------------- /expo-out.js: -------------------------------------------------------------------------------- 1 | function expoOut(t) { 2 | return t === 1.0 ? t : 1.0 - Math.pow(2.0, -10.0 * t) 3 | } 4 | 5 | module.exports = expoOut -------------------------------------------------------------------------------- /index.js: -------------------------------------------------------------------------------- 1 | module.exports = { 2 | 'backInOut': require('./back-in-out'), 3 | 'backIn': require('./back-in'), 4 | 'backOut': require('./back-out'), 5 | 'bounceInOut': require('./bounce-in-out'), 6 | 'bounceIn': require('./bounce-in'), 7 | 'bounceOut': require('./bounce-out'), 8 | 'circInOut': require('./circ-in-out'), 9 | 'circIn': require('./circ-in'), 10 | 'circOut': require('./circ-out'), 11 | 'cubicInOut': require('./cubic-in-out'), 12 | 'cubicIn': require('./cubic-in'), 13 | 'cubicOut': require('./cubic-out'), 14 | 'elasticInOut': require('./elastic-in-out'), 15 | 'elasticIn': require('./elastic-in'), 16 | 'elasticOut': require('./elastic-out'), 17 | 'expoInOut': require('./expo-in-out'), 18 | 'expoIn': require('./expo-in'), 19 | 'expoOut': require('./expo-out'), 20 | 'linear': require('./linear'), 21 | 'quadInOut': require('./quad-in-out'), 22 | 'quadIn': require('./quad-in'), 23 | 'quadOut': require('./quad-out'), 24 | 'quartInOut': require('./quart-in-out'), 25 | 'quartIn': require('./quart-in'), 26 | 'quartOut': require('./quart-out'), 27 | 'quintInOut': require('./quint-in-out'), 28 | 'quintIn': require('./quint-in'), 29 | 'quintOut': require('./quint-out'), 30 | 'sineInOut': require('./sine-in-out'), 31 | 'sineIn': require('./sine-in'), 32 | 'sineOut': require('./sine-out') 33 | } -------------------------------------------------------------------------------- /linear.js: -------------------------------------------------------------------------------- 1 | function linear(t) { 2 | return t 3 | } 4 | 5 | module.exports = linear -------------------------------------------------------------------------------- /package.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "eases", 3 | "version": "1.0.8", 4 | "description": "grab bag of easing equations", 5 | "main": "index.js", 6 | "license": "MIT", 7 | "author": "Matt DesLauriers ", 8 | "dependencies": {}, 9 | "devDependencies": { 10 | "tape": "~2.13.2" 11 | }, 12 | "scripts": { 13 | "test": "node test.js", 14 | "dev": "beefy demo/index" 15 | }, 16 | "testling": { 17 | "files": "test.js", 18 | "browsers": [ 19 | "ie/6..latest", 20 | "chrome/22..latest", 21 | "firefox/16..latest", 22 | "safari/latest", 23 | "opera/11.0..latest", 24 | "iphone/6", 25 | "ipad/6", 26 | "android-browser/latest" 27 | ] 28 | }, 29 | "repository": { 30 | "type": "git", 31 | "url": "git://github.com/mattdesl/eases.git" 32 | }, 33 | "homepage": "https://github.com/mattdesl/eases", 34 | "bugs": { 35 | "url": "https://github.com/mattdesl/eases/issues" 36 | }, 37 | "keywords": [ 38 | "ease", 39 | "eases", 40 | "robert", 41 | "penner", 42 | "easing", 43 | "easings", 44 | "linear", 45 | "lerp", 46 | "animation", 47 | "tween", 48 | "anim", 49 | "animations", 50 | "tweening", 51 | "tweens", 52 | "function", 53 | "functions", 54 | "expo", 55 | "quint", 56 | "quadratic" 57 | ] 58 | } 59 | -------------------------------------------------------------------------------- /quad-in-out.js: -------------------------------------------------------------------------------- 1 | function quadInOut(t) { 2 | t /= 0.5 3 | if (t < 1) return 0.5*t*t 4 | t-- 5 | return -0.5 * (t*(t-2) - 1) 6 | } 7 | 8 | module.exports = quadInOut -------------------------------------------------------------------------------- /quad-in.js: -------------------------------------------------------------------------------- 1 | function quadIn(t) { 2 | return t * t 3 | } 4 | 5 | module.exports = quadIn -------------------------------------------------------------------------------- /quad-out.js: -------------------------------------------------------------------------------- 1 | function quadOut(t) { 2 | return -t * (t - 2.0) 3 | } 4 | 5 | module.exports = quadOut -------------------------------------------------------------------------------- /quart-in-out.js: -------------------------------------------------------------------------------- 1 | function quarticInOut(t) { 2 | return t < 0.5 3 | ? +8.0 * Math.pow(t, 4.0) 4 | : -8.0 * Math.pow(t - 1.0, 4.0) + 1.0 5 | } 6 | 7 | module.exports = quarticInOut -------------------------------------------------------------------------------- /quart-in.js: -------------------------------------------------------------------------------- 1 | function quarticIn(t) { 2 | return Math.pow(t, 4.0) 3 | } 4 | 5 | module.exports = quarticIn -------------------------------------------------------------------------------- /quart-out.js: -------------------------------------------------------------------------------- 1 | function quarticOut(t) { 2 | return Math.pow(t - 1.0, 3.0) * (1.0 - t) + 1.0 3 | } 4 | 5 | module.exports = quarticOut -------------------------------------------------------------------------------- /quint-in-out.js: -------------------------------------------------------------------------------- 1 | function qinticInOut(t) { 2 | if ( ( t *= 2 ) < 1 ) return 0.5 * t * t * t * t * t 3 | return 0.5 * ( ( t -= 2 ) * t * t * t * t + 2 ) 4 | } 5 | 6 | module.exports = qinticInOut -------------------------------------------------------------------------------- /quint-in.js: -------------------------------------------------------------------------------- 1 | function qinticIn(t) { 2 | return t * t * t * t * t 3 | } 4 | 5 | module.exports = qinticIn -------------------------------------------------------------------------------- /quint-out.js: -------------------------------------------------------------------------------- 1 | function qinticOut(t) { 2 | return --t * t * t * t * t + 1 3 | } 4 | 5 | module.exports = qinticOut -------------------------------------------------------------------------------- /sine-in-out.js: -------------------------------------------------------------------------------- 1 | function sineInOut(t) { 2 | return -0.5 * (Math.cos(Math.PI*t) - 1) 3 | } 4 | 5 | module.exports = sineInOut -------------------------------------------------------------------------------- /sine-in.js: -------------------------------------------------------------------------------- 1 | function sineIn (t) { 2 | var v = Math.cos(t * Math.PI * 0.5) 3 | if (Math.abs(v) < 1e-14) return 1 4 | else return 1 - v 5 | } 6 | 7 | module.exports = sineIn 8 | -------------------------------------------------------------------------------- /sine-out.js: -------------------------------------------------------------------------------- 1 | function sineOut(t) { 2 | return Math.sin(t * Math.PI/2) 3 | } 4 | 5 | module.exports = sineOut -------------------------------------------------------------------------------- /test.js: -------------------------------------------------------------------------------- 1 | // Could do with proper tests... 2 | 3 | var eases = require('./') 4 | var test = require('tape').test 5 | 6 | var outsideRange = [ 7 | 'elasticIn', 'elasticOut', 'elasticInOut', 8 | 'backIn', 'backOut', 'backInOut', 9 | 'bounceIn', 'bounceOut', 'bounceInOut', 10 | ] 11 | 12 | test('eases return number between 0 and 1', function (t) { 13 | for (var k in eases) { 14 | var f = eases[k] 15 | if (outsideRange.indexOf(k) === -1) { 16 | t.equal(f(1), 1, k) 17 | t.equal(f(0), 0, k) 18 | } 19 | } 20 | t.end() 21 | }) 22 | --------------------------------------------------------------------------------