To create motion on the screen, there are various approaches. You could hardcode or use a physics engine for example. One of the popular and proven approach is animation with Robert Penner’s easing equations. Now, animation using easing functions with cubic-bezier coordinates is gaining popularity, especially for web development with CSS. In this post I’ll would like to share how I’ve “eased” Robert Penner Easing equations into the cubic-bezier coordinates easing functions.

TL;DR? Check out the interactive example here.

**Easing**

Easing (also referred to as Tweening) is an interesting topic, and there is a great deal of good articles on the net. Likely you are familiar with this if you have done some animation (be it javascript, actionscript, css, glsl, flash, after effects), otherwise check out this good read.

**Easing Equations**

So you understand about easing but you may not know who Robert Penner is and what his easing equations are. For that, I would suggest reading the chapter from his book about Motion, Tweening, and Easing. It may be old, but this was probably what popularized or influenced the way programmers go about coding or thinking about animation. Penner’s equations has been implemented in various languages and for various platforms (even if it’s not, it’d be easy to). Pick any popular animation library and it already be using his easing equations.

For myself, I love tween.js implementation of the easing equations, not just because mrdoob uses it, but because it concisely simplifies the equations to a single factor k which you can easily use it anywhere (and there are others who are rediscovering that it can be done).

**Cubic Bezier Curves**

Cubic bezier curves are used in many applications especially in graphics, motion graphics and animation software (to list some: illustrator, sketch, after effects).For a very simple introduction to Cubic Bezier Curves, you can watch this video. For some reasons, I find cubic bezier both simple and complex – huge amount of possibilities can be created with just 2 control points.

**Cubic Bezier Tools**

Which would explain the number of popular cubic bezier tools for creating css animations. It was probably Matthew Lein’s Ceaser tool that introduced the concept of approximated Penner Equations with cubic beziers (which was tweaked by hand if I recall him correctly in a twitter conversation with Lea Verou).

**Experimentations**

I eventually found that the Ceaser easing functions made it to places like LESS css mixins, Sass/SCSS and Easings.net. I started extracting these values into a JSON format so it’d be easy to use in javascript.

The next thing I did was try plotting the cubic bezier on canvas and add animations for visualizations. What I observed was that Ceaser’s parameters typically followed the shape of Penner’s equations, however the resulting values were still an approximation. I stacked the graphed Robert Penner’s equations from tween.js with ceaser’s and there was some amount of deviations, which is amplified with side-by-side animations or when charted on a larger canvas. One way to improve these easing functions is to fix and adjust by importing it into a tool to tweak the control points until it match up more.

**CustomMediaTimingFunction**

Fortunately, I found another Objective-C library called CustomMediaTimingFunction that also tries approximating Robert Penner’s easing equations. My guess is that native cubic bezier support with CAMediaTimingFunction in IOS/Mac was another reason why someone wanted to convert Penner’s equations to cubic bezier functions.

As with the previous Ceaser’s equations, I extracted them to javascript, and draw them on the canvas with Penner’s equations. There were still some noticeable differences but I was pleasantly surprise to find them more accurate to Penner’s equations. I also found that KinkumaDesign’s equations were pretty off for the ease-out equations (possibly due to a different definition on what ease-out is). Another difference was that in addition to ease-in-out, there was ease-out-in easing functions. So generally KinkumaDesign’s was pretty good and perhaps what I needed to do is to hand tweak their values to make it better.

**Curve Fitting**

But I wasn’t satisfied with the thought of hand tweaking this values, even with a tool, and started thinking of how I could fit a bezier curve to match Penner’s equations. I remembered about a curve fitting algorithm by Philip J. Schneider (From 1990 Graphics Gems “An Algorithm for Automatically Fitting Digitized Curves”). I actually ported his C code to JS before but I just grabbed this gist, generated points from Penner’s equations and tested if the curve fitting algorithm worked. The result: the curve fitting seemed to generate bezier curve almost similar in shape to the original, but the differences was too great to be accurate. It might be possible that I could tweak the curve fitting parameters, but I didn’t want to go down that route and decided to do the brute force approach.

**Brute Force**

I decided that humans may not be precise when it comes to adjusting parameters, but the computer may be fast enough to try all the different combinations. The idea that I had for brute forcing is this: There are 2 control coordinates, which has a total of 4 values. If we subdivide each value to say 10, we will have 10×10 = 100 possibility for each control point. The estimated total combinations to check for is 100 * 100 = 10,000, which isn’t too bad. For each generated cubic bezier coordinates combination, I will generate the range of values and compare with the range of values generated with Penner’s equations. For comparing the ranges, the differences are squared individually and then sum. Comparing different combinations, only the coordinates which gives the least sum of squared differences will be kept. I ran this with node.js, and the subdivisions of 10-20 ran pretty quickly. Subdivisions of 25 (giving precision of up to 0.04) started give pretty accurate approximation, although the process starts to be slightly slower. For subdivision of 50 units (0.02 precision), it started to take a couple minutes to finish. In case you’re interested, the related node.js script (which is just a couple hundred of lines) is here.

So here are the bruteforce results which I think are pretty satisfactory

`QuadIn: [ 0.26, 0, 0.6, 0.2 ]`

QuadOut: [ 0.4, 0.8, 0.74, 1 ]

QuadInOut: [ 0.48, 0.04, 0.52, 0.96 ]

CubicIn: [ 0.32, 0, 0.66, -0.02 ]

CubicOut: [ 0.34, 1.02, 0.68, 1 ]

CubicInOut: [ 0.62, -0.04, 0.38, 1.04 ]

QuartIn: [ 0.46, 0, 0.74, -0.04 ]

QuartOut: [ 0.26, 1.04, 0.54, 1 ]

QuartInOut: [ 0.7, -0.1, 0.3, 1.1 ]

QuintIn: [ 0.52, 0, 0.78, -0.1 ]

QuintOut: [ 0.22, 1.1, 0.48, 1 ]

QuintInOut: [ 0.76, -0.14, 0.24, 1.14 ]

SineIn: [ 0.32, 0, 0.6, 0.36 ]

SineOut: [ 0.4, 0.64, 0.68, 1 ]

SineInOut: [ 0.36, 0, 0.64, 1 ]

ExpoIn: [ 0.62, 0.02, 0.84, -0.08 ]

ExpoOut: [ 0.16, 1.08, 0.38, 0.98 ]

ExpoInOut: [ 0.84, -0.12, 0.16, 1.12 ]

CircIn: [ 0.54, 0, 1, 0.44 ]

CircOut: [ 0, 0.56, 0.46, 1 ]

CircInOut: [ 0.88, 0.14, 0.12, 0.86 ]

If you prefer to to keep values clipped to 0..1, here are the parameters

`QuadIn: [ 0.26, 0, 0.6, 0.2 ]`

QuadOut: [ 0.4, 0.8, 0.74, 1 ]

QuadInOut: [ 0.48, 0.04, 0.52, 0.96 ]

CubicIn: [ 0.4, 0, 0.68, 0.06 ]

CubicOut: [ 0.32, 0.94, 0.6, 1 ]

CubicInOut: [ 0.66, 0, 0.34, 1 ]

QuartIn: [ 0.52, 0, 0.74, 0 ]

QuartOut: [ 0.26, 1, 0.48, 1 ]

QuartInOut: [ 0.76, 0, 0.24, 1 ]

QuintIn: [ 0.64, 0, 0.78, 0 ]

QuintOut: [ 0.22, 1, 0.36, 1 ]

QuintInOut: [ 0.84, 0, 0.16, 1 ]

SineIn: [ 0.32, 0, 0.6, 0.36 ]

SineOut: [ 0.4, 0.64, 0.68, 1 ]

SineInOut: [ 0.36, 0, 0.64, 1 ]

ExpoIn: [ 0.66, 0, 0.86, 0 ]

ExpoOut: [ 0.14, 1, 0.34, 1 ]

ExpoInOut: [ 0.9, 0, 0.1, 1 ]

CircIn: [ 0.54, 0, 1, 0.44 ]

CircOut: [ 0, 0.56, 0.46, 1 ]

CircInOut: [ 0.88, 0.14, 0.12, 0.86 ]

**Observations**

- ease-in and ease-out typically fits pretty well
- It is more difficult to fit the higher powered ease-in-out eg. QuintInOut. Sometimes the best fit creates a little bounce at the edges, which is then better to used the clipped parameters or adjust the control points a little. There are also certain easing equations eg. bounce which are not directly portable. For these cases, it might be better to multiple cubic-bezier-easing-functions.
- getYforX() for a cubic bezier function is not simply
`P0 * ( 1 - u )3 + P1 * 3 * u * ( 1 - u )2 + P2 * 3 * u2 * ( 1 - u ) + P3 * u3`

. X needs to be re-parameterize to t before getting Y. A couple of npm modules are available if you’re lazy to implement this.

**Possible Improvements**

- smarter brute force – If we were to create more subdivisions for more accurate results, the entire brute force process would take exponentially longer. To reduce this time, a) we could run on multiprocessors, b) run it on the gpu eg.https://github.com/andyhall/glsl-projectron c) be a little smarter on which coordinates run brute forces on
- smarter fitting – perhaps there are better curve fitting algorithm that would make this bruteforce approach less relevant eg. this

While this may be something academic to do, I don’t think its pretty necessary right now. It’s probably more important to think what we can do with it, and what we can do going forward.

**Conclusion & Going Forward**

So in this post I’ve written a new cubic bezier tool, suggested a new set of Cubic Bezier approximations for Robert Penner’s easing equations, and showed a little of that process.

What I’ve done here might simply just a improvement from the Ceaser’s and KinkumaDesign’s parameters, or you could think of it as a “purer” form of Penner’s implementation with cubic bezier. Also I started thinking about these because of the possibilities of using Penner’s equations while making it editable easily using curves for my animation tool Timeliner. There might also be other curves and splines to consider, but allowing Penner’s equations to map to cubic bezier curves is a start. There is also a thread on better integrating editable and non-editable easing in blender which is worth considering.

Hopefully, someone finds this useful. The code is on github. Sorry if it looks like mess, it was hacked overnight.

Merry Christmas and have a happy new year!