Omi 拥抱 60FPS 的 Web 动画

写在前面

omi 框架 正式发布了 → omi-transform。

made css3 transform super easy. made 60 fps easy.

作为 omi 组件化开发特效运动解决方案，让你轻松在omi项目里快速简便支持css3 transform设置。css3transform 是经受过海量项目洗礼的，作为移动 web 特效解决方案，在微信、手q兴趣部落、日迹、qq群、qq附近等项目中广泛使用，以激进的修改dom属性为代价，带来极为便利的可编程性。

你可以通过快速了解它。

上面官网的例子都是原生 js 的，css3transform 也拥有react版本，你也可以在 react 中以声明式的方式使用 css3transform：

render() {
    return (
        <transform
          translatex={100}
          scalex={0.5}
          originx={0.5}>
          <div>你要运动的 dom</div>
        </transform>
    )
}

这都不是重点，重点是 omi-transform。

3分钟掌握 omi-transform

通过npm安装

npm install omi-transform

使用

import { render, weelement, define } from "omi"
import "omi-transform"

define("my-app", class extends weelement {
  static observe = true

  install() {
    this.data.rotatez = 30
    this.linkref = (e) => {
      this.animdiv = e
    }
  }

  installed() {
    setinterval(() => {
      //slow
      //this.data.rotatez += 2

      //fast
      this.animdiv.rotatez += 2
      //sync for update call of any scenario
      this.data.rotatez = this.animdiv.rotatez
    }, 16)
  }

  render(props, data) {
    return (
      <css3-transform rotatez={data.rotatez} translatex={0} perspective={0} >
        <div ref={this.linkref}>
          omi-transform
        </div>
      </css3-transform>
    )
  }
})

render(<my-app />, "body")

• 把需要运动的 dom 使用 <css3-transform></css3-transform> 包裹
• 在需要使用 css3transform 的 dom 上标记 ref 用来直接操作 dom
• 在组件函数里便可以使用 this.refs.animdiv 来读取或者设置 css transform属性
• this.refs.xxx 支持 "translatex", "translatey", "translatez", "scalex", "scaley", "scalez", "rotatex", "rotatey", "rotatez", "skewx", "skewy", "originx", "originy", "originz", "perspective" 这些属性设置和读取
• perspective 表示透视投影的距离

组件里的某个 dom 在运动过程中，可能会由于其他逻辑，进行 update。有可能是用户交互，有可能是数据返回的回调。所以，update 前后，dom 的状态的保留显得尤其重要，不然的话就会有闪烁、跳跃的效果或者其他显示逻辑错误。

可以看到上面的代码在 dom 运动过程中时不进行 diff ？组件不进行 update ？万一组件 update，所有运动的状态都会丢失？omi 怎么解决这个问题？上面的代码已经给出了答案：

使用 this.data.rotatez 来同步运动 dom 的状态防止意外的刷新(update)

支持的属性

property	describe
translatex	translatex
translatey	translatey
translatez	translatez
scalex	scalex
scaley	scaley
scalez	scalez
rotatex	rotatex
rotatey	rotatey
rotatez	rotatez
skewx	skewx
skewy	skewy
originx	the basic x point of rotation
originy	the basic y point of rotation
originz	the basic z point of rotation
perspective	perspective projection distance

你既可以 get 也可以 set。

性能对比

因为 react 版本会有 diff 过程，然后 apply diff to dom 的过程，state 改变不会整个 innerhtml 全部替换，所以对浏览器渲染来说还是很便宜，但是在 js 里 diff 的过程的耗时还是需要去 profiles 一把，如果耗时严重，不在 webworker 里跑还是会卡住ui线程导致卡顿，动画卡顿丢帧、交互延缓等。所以要看一看 cpu 的耗时还是很有必要的。

下面数据是对比 omi-transform 和 react-transform，两种方式使用 chrome profiles 了一把。

先看总耗时对比：

react-transform：

omi-transform：

• react 在8739秒内cpu耗时花费了近似1686ms
• omi 方式在9254ms秒内cpu耗时花费近似700ms

在不进行 profiles 就能想象到 react 是一定会更慢一些，因为 state 的改变要走把 react 生命周期走一遍，但是可以看到 react 的耗时还是在可以接受的范围，没有慢到难以接受。

而 omi 的方式则和传统的原生 js 的耗时一模一样。因为运动过程不进行dom diff，直接操作 dom!!

omi 自身对比

//slow
this.data.rotatez += 2

//fast
this.animdiv.rotatez += 2
this.data.rotatez = this.animdiv.rotatez

主要对比上面两个代码块的执行效率，打开谷歌浏览器的 performance 运行 10 秒左右，打开 summary 对比:

slow	fast

可以看到 omi 的两种方式都拥有很高性能，10秒钟内拥有大量的空闲时间，但是 fast 确实更加 fast，scripting 的耗时更短。但是优势不明显是为什么？因为 dom 结构简单，如果 dom 结构越复杂， fast 直接操作 dom 的方式会把 slow 的方式甩开一大截！下面进行验证一下:

先发 render 的 dom 结构修改成复杂的:

打开谷歌浏览器的 performance 运行 10 秒左右，打开 summary 对比:

slow	fast

可以看到 scripting time 已经拉开了差距！

对比前后两次的数据：

dom 结构	slow	fast
简单
复杂

可以看到 fast 的前后两次没有太大差别，slow 前后两次差距巨大。那么 fast 内核 css3transform 原理是什么？

css3transform

安装

npm install css3transform

api

transform(domelement, [notperspective])

通过上面一行代码的调用，就可以设置或者读取 domelement 的"translatex", "translatey", "translatez", "scalex", "scaley", "scalez", "rotatex", "rotatey", "rotatez", "skewx", "skewy", "originx", "originy", "originz"！

大道至简。

使用姿势

transform(domelement)//or transform(domelement, true);

//set 
domelement.translatex = 100
domelement.scalex = 0.5
domelement.originx = 50

//get 
console.log(domelement.translatex)

传统的css3编程的问题

以前，我们一般使用animate.css、zepto/jquery的animate方法或者tween.js+css3进行交互特效编程。总结下来有三个缺点：

• 不直观
• 不直接
• 不方便

不直观

看下面这张图：

顺序影响结果，不直观。那么为什么会是这个结果？可以通过new webkitcssmatrix(transform_str)对比最终的matrix。

这也直接说明了矩阵不符合交换律。a*b != b*a

不直接

zepto姿势：

$("#some_element").animate({
  opacity: 0.25, left: '50px',
  color: '#abcdef',
  rotatez: '45deg', translate3d: '0,10px,0'
}, 500, 'ease-out')

translate3d: '0,10px,0'非常不方便，无法step递进递减控制。更别提配合一些运动或者时间的库来编程了。可能你会反驳'ease-out'不就可以实现缓动吗？但是如果我需要让x和y以及z分别对应不同的缓动函数，这种基于字符串编程的形式就费劲了~~
这里还需要注意的是，zepto里的顺序也会影响结果。因为其最后也是拼成string赋给dom元素。

tween.js姿势

var position = { x: 100, y: 100, rotation: 0 },
    target = document.getelementbyid('target')

    new tween.tween(position)
    .to({ x: 700, y: 200, rotation: 359 }, 2000)
    .delay(1000)
    .easing(tween.easing.elastic.inout)
    .onupdate(function update() {
        var t_str= 'translatex(' + position.x + 'px) translatey(' + position.y + 'px) rotate(' + math.floor(position.rotation) + 'deg)'
        element.style.transform = element.style.mstransform = element.style.otransform = element.style.moztransform = element.style.webkittransform = t_str
    });

使用字符串的方式，看着就心累。更别提写的过程要遭受多少折磨。

animate.css姿势:

@keyframes pulse {
  from {
    -webkit-transform: scale3d(1, 1, 1);
    transform: scale3d(1, 1, 1);
  }

  50% {
    -webkit-transform: scale3d(1.05, 1.05, 1.05);
    transform: scale3d(1.05, 1.05, 1.05);
  }

  to {
    -webkit-transform: scale3d(1, 1, 1);
    transform: scale3d(1, 1, 1);
  }
}

animate.css封装了一大堆关键帧动画，开发者只需要关心添加或者移除相关的动画的class便可以。这一定程度上给交互特效带来了极大的遍历，但是要有硬伤：

• 可编程性不够高
• 适用于简单场景
• 只有 end 回调，没有 change 回调

不方便

transform的旋转点基准点默认是在中心，但是有些是时候，不系统在中心，我们传统的做法是使用transform-origin来设置基准点。

注意，是另一个属性transform-origin，而不是transform。但是如果需要运动transform-origin呢？这种设计是不是就废了？有没有需要运动origin的场景？这个在游戏设计中是经常会使用的到，这个以后另外单独开篇再说，事实就是，有场景是需要运动origin来达到某种效果。

小结

基于上面种种不便，所以有了css3transform！

• css3transform 专注于css3 transform读取和设置的一个超轻量级js库，大大提高了css3 transform的可编程性
• css3transform 高度抽象，不与任何时间、运动框架捆绑，所以可以和任意时间、和运动框架轻松搭配使用
• css3transform 使用matrix3d为最终输出给dom对象，硬件加速的同时，不失去可编程性
• css3transform 拥有超级易用的api，一分钟轻松上手，二分钟嵌入真实项目实战
• css3transform 扩展了transform本身的能力，让transform origin更加方便

实战

你可以配合 createjs 的 tweenjs ，轻松制作出上面的摇摆特效:

var element = document.queryselector("#test")
transform(element)
element.originy = 100
element.skewx = -20

var tween = createjs.tween,
    sineinoutease = createjs.ease.sineinout
tween.get(element, {loop: true}).to({scaley: .8}, 450, sineinoutease).to({scaley: 1}, 450, sineinoutease)
tween.get(element, {loop: true}).to({skewx: 20}, 900, sineinoutease).to({skewx: -20}, 900, sineinoutease)

上面的代码很精简。这里稍微解释下：

• 元素的初始skewx是-20，为了和scale的步调一致
• 元素的originy是100，为的以企鹅的bottom center为基准点

可以看到，由于css3transform高度抽象，可以和tweenjs轻松搭配使用，没有任何压力。

原理

css3transform 不仅仅可以mix css3 transform 到 dom 元素，还能 mix 到任意的对象字面量，也可以把 css3transform 当作工具，他提供一些基础的数学能力。

这里需要特别注意，以前的姿势可以继续使用，这里另外三种使用姿势。

语法1

transform(obj, [notperspective]);

如你所见，其他方式都不用变。只是第一个参数不仅仅可以传dom元素，也可以传任意对象字面量等。

不卖关子，先看使用姿势

var element = document.queryselector("#test"),
    obj = {}

transform(obj)

obj.rotatez = 90

element.style.transform = element.style.mstransform = element.style.otransform = element.style.moztransform = element.style.webkittransform = obj.transform

看到了没有，你不仅可以传 dom 元素进去，也可以传对象字面量。你可以把 obj.transform 打印出来，上面是选择了90度，所以它生成出来的 matrix 是：

perspective(500px) matrix3d(0,1,0,0,-1,0,0,0,0,0,1,0,0,0,0,1)

你同样也可以关闭透视投影，如：

var element = document.queryselector("#test"),
    obj = {}
//关闭透视投影
transform(obj, true)

obj.rotatez = 90

element.style.transform = element.style.mstransform = element.style.otransform = element.style.moztransform = element.style.webkittransform = obj.transform

生成出来的matrix是：

matrix3d(0,1,0,0,-1,0,0,0,0,0,1,0,0,0,0,1)

那么运动的姿势呢？这里配合的示例如下：

var element = document.queryselector("#test"),
    obj = { translatex: 0, translatey: 0 }

transform(obj);

var tween = new tween.tween(obj)
    .to({ translatex: 100, translatey: 100 }, 1000)
    .onupdate(function () {
        element.style.transform = element.style.mstransform = element.style.otransform = element.style.moztransform = element.style.webkittransform = obj.transform
    })
    .start()

requestanimationframe(animate)

function animate(time) {
    requestanimationframe(animate)
    tween.update(time)
}

那么如果用传统的姿势是？

var element = document.queryselector("#test")

transform(element)

var tween = new tween.tween({ translatex: element.translatex, translatey: element.translatey })
    .to({ translatex: 100, translatey: 100 }, 1000)
    .onupdate(function () {
        element.translatex = this.translatex
        element.translatey = this.translatey
    })
    .start()

requestanimationframe(animate)

function animate(time) {
    requestanimationframe(animate)
    tween.update(time)
}

这里由于 tween.tween会去遍历所以的属性并且设置初始值，如tween里面的代码：

 // set all starting values present on the target object
for (var field in object) {
    _valuesstart[field] = parsefloat(object[field], 10)
}

所以不能直接把 new tween.tween(element)。
因为在start之前，程序其实已经可以完全收集到所有需要to的属性，去运动便可以。我们可以自己封装一个tween去支持这种简便的方式。如：

var tween = function (obj) {
    this.obj = obj
    return this
}

tween.prototype = {
    to: function (targets, duration, easing) {
        this.duration = duration
        this.targets = targets
        return this
    },
    start: function () {
        this.starttime = new date()
        this._begintick()
    },
    _begintick: function () {
        var _startvalues = {},
            targets = this.targets
        for (var key in targets) {
            if (targets.hasownproperty(key)) {
                _startvalues[key] = this.obj[key]
            }
        }
        var self  = this
        this._interval = setinterval(function () {
            var dt = new date() - self.starttime
            for (var key in targets) {
                if (targets.hasownproperty(key)) {
                    if (dt >= self.duration) {
                        clearinterval(self._interval)
                    } else {
                        var p = dt / self.duration;
                        var dv = targets[key] - self.obj[key]
                        self.obj[key] += dv * p
                    }
                }
            }
        }, 15)

    }
}

这里为了简便使用setinterval去进行loop，当然可以换成其他方式。现在便可以使用如下方式：

var element = document.queryselector("#test")
transform(element)
var tween = new tween(element)
    .to({ translatex: 100, translatey: 100 }, 1000)
    .start();

当然这有点跑题了。这里只是对比直接使用dom挂载和使用第三方对象挂载的区别。第三方挂载有点隔山打牛的感觉。
当然..，还没有完，不仅仅可以上面那个样子。那还可以把css3transform完全当作一个计算工具来用。

语法2

 transform.getmatrix3d(option)

姿势

var matrix3d = transform.getmatrix3d({
    translatex: 0,
    translatey: 100,
    scalex:2
})
console.log(matrix3d)

打印出来你将得到下面的值：

你想用这个值来干什么就干什么吧。看css3transform源码可以得到 transform.getmatrix3d一共支持的属性：

transform.getmatrix3d = function (option) {
    var defaultoption = {
        translatex: 0,
        translatey: 0,
        translatez: 0,
        rotatex: 0,
        rotatey: 0,
        rotatez: 0,
        skewx: 0,
        skewy: 0,
        originx: 0,
        originy: 0,
        originz: 0,
        scalex: 1,
        scaley: 1,
        scalez: 1
    };
    for (var key in option) {
    ...
    ...
    ...

}

语法3

 transform.getmatrix2d(option)

不仅仅是3d matrix， css3transform也提供了2d的工具函数支持。

姿势

var matrix2d = transform.getmatrix2d({
    translatex: 0,
    translatey: 100,
    scalex:2
});
console.log(matrix2d);

打印出来你将得到下面的值：

• a 水平缩放
• b 水平拉伸
• c 垂直拉伸
• d 垂直缩放
• tx 水平位移
• ty 垂直位移

那么得到这个matrix2d有什么用?

• 缩放：scale(sx, sy) 等同于 matrix(sx, 0, 0, sy, 0, 0);
• 平移：translate(tx, ty) 等同于 matrix(1, 0, 0, 1, tx, ty);
• 旋转：rotate(deg) 等同于 matrix(cos(deg), sin(deg), -sin(deg), cos(deg), 0, 0);
• 拉伸：skew(degx, degy) 等同于 matrix(1, tan(degy), tan(degx), 1, 0, 0);

看css3transform源码可以得到 transform.getmatrix2d一共支持的属性：

transform.getmatrix2d = function(option){
    var defaultoption = {
        translatex: 0,
        translatey: 0,
        rotation: 0,
        skewx: 0,
        skewy: 0,
        originx: 0,
        originy: 0,
        scalex: 1,
        scaley: 1
    };
    ...
    ...
    ...
}

特别注意事项

transform.getmatrix2d 和transform.getmatrix3d都是支持origin特性，请和transform-origin说拜拜
transform.getmatrix2d 和transform.getmatrix3d没有使用传统的math.tan去实现shew，取而代之的是half of rotation

如2d的skew：

math.cos(skewy), math.sin(skewy), -math.sin(skewx), math.cos(skewx)

以前腾讯ieg的同学问过为什么使用half of rotation，而不使用math.tan？
原因很简单，math.tan扭曲力度特别大，而且会有无穷大的值导致扭曲横跨整个屏幕。

而half of rotation则不会。

getmatrix2d有用吗？

用于dom transformation时候，可以用于兼容不支持css3 3d transforms的浏览器

如，我们可以很轻松的把一些transformation属性转换成css3属性赋给dom:

var matrix = transform.getmatrix2d({
    rotation: 30,
    scalex: 0.5,
    scaley: 0.5,
    translatex: 100
});
ele.style.transform = ele.style.mstransform = ele.style.otransform = ele.style.moztransform = ele.style.webkittransform = "matrix(" + [matrix.a, matrix.b, matrix.c, matrix.d, matrix.tx, matrix.ty].join(",") + ")"

用于canvas和svg transformation

什么？还能用于canvas和svg?是的，举个例子，在canvas画一个旋转30度、缩小成0.5倍，并且平移（200,200）的图片：

var canvas = document.getelementbyid("ourcanvas"),
    ctx = canvas.getcontext("2d"),
    img = new image(),
    rotation = 30 * math.pi / 180

img.onload = function () {
    ctx.sava();
    ctx.settransform(
        0.5 * math.cos(rotation), 0.5 * math.sin(rotation),
        -0.5 * math.sin(rotation), 0.5 * math.cos(rotation),
        200, 200
    )
    ctx.drawimage(img, 0, 0)
    ctx.restore()
};

img.src = "asset/img/test.png"

上面是我们传统的姿势。使用transform.getmatrix2d 之后，变成这个样子：

var canvas = document.getelementbyid("ourcanvas"),
    ctx = canvas.getcontext("2d"),
    img = new image()

var matrix = transform.getmatrix2d({
    rotation: 30,
    scalex: 0.5,
    scaley: 0.5,
    translatex: 200,
    translatey: 200
});

img.onload = function () {
    ctx.sava();
    ctx.settransform(matrix.a, matrix.b, matrix.c, matrix.d, matrix.tx, matrix.ty);
    ctx.drawimage(img, 0, 0);
    ctx.restore();
}

img.src = "asset/img/test.png"

可以看到，这里让开发者不用自己去拼凑matrix。svg的粒子就不再举例，和用于dom的例子差不多，相信大家能够很快搞定。

star & fork

→ omi-transform