Animatable 协议
我们之所以能看见动画的效果,是因为 SwiftUI 在视图变化的首尾状态之间不断地重绘视图,一系列静态视图因“视觉暂留”作用而造成一种连续的视觉印象,让我们感觉视图动起来了,这其实也是电影的原理。比如一个视图需要从透明度 0 变成 1,SwiftUI 会在 0 和 1 之间不断地作插值运算,不断重绘不同透明度的视图(0,0.1,0.2,0.3 … 1.0),直到视图不再变化。如果使用 .linear 指定动画效果,那么视图的重绘过程是匀速的,如果使用 .easeOut,那么重绘的过程是先快后慢,以此类推。
SwiftUI 通过 Animatable 协议定义视图该如何动画,它的声明如下:
1
2
3
4
5
6
7
8
public protocol Animatable {
/// The type defining the data to animate.
associatedtype AnimatableData : VectorArithmetic
/// The data to animate.
var animatableData : Self . AnimatableData { get set }
}
该协议只有一个关联类型的属性 animatableData,正是它告诉视图该如何去做动画。SwiftUI 中的各种形状、布局都已经实现该协议,所以我们能够使用动画流畅地改变形状、切换布局等。
> 查看示例
示例中自定义了一个曲线形状 Line1,通过参数 yFactor 线条的弯曲程度:
1
2
3
4
5
6
7
8
9
10
11
12
13
fileprivate struct Line1 : Shape {
var controYFactor : Double = 0
func path ( in rect : CGRect ) -> Path {
var path = Path ()
path . move ( to : . init ( x : 0 , y : rect . midY ))
path . addQuadCurve (
to : . init ( x : rect . maxX , y : rect . midY ),
control : . init ( x : rect . midX , y : rect . midY * controYFactor )
)
return path
}
}
我们期望给它一个弹性动画:
1
2
3
4
5
6
7
8
9
10
11
12
@ State private var l1_controlYFactor = 0.0
Line1 ( controYFactor : l1_controlYFactor )
. stroke (. blue , style : strokeStyle )
Button ( "Update" ) {
withAnimation (
. spring ( response : 0.3 , dampingFraction : 0.3 )
) {
l1_controlYFactor = . random ( in : 0. .. 2 )
}
}
然后事与愿违,因为 SwiftUI 不知道该如何给 Line1 视图做重绘,我们得通过 Animatable 协议告诉它该给哪些数据做插值运算。
Shape 本身已经实现 Animatable 协议,其默认的 animatableData 属性是 EmptyAnimatableData 实例,表示没有可动画的 animatableData 属性。
我们现在需要使曲线动起来,关键就是实现 Animatable 协议,使 controYFactor 成为可动画的数据:
1
2
3
4
var animatableData : Double {
get { controYFactor }
set { controYFactor = newValue }
}
当改变 controYFactor 参数时,SwiftUI 会在旧值和新值之间作插值运算,不断地调用 get 和 set 方法,驱动视图的更新,动画的效果就出来了。
多个动画数据
AnimatablePair
Anmatable 协议中的 anmatableData 是关联类型:
1
associatedtype AnimatableData : VectorArithmetic
VectorArithmetic 是一个用于向量计算的协议,它继承自支持加减法的协议 AdditiveArithmetic 。anmatableData 必须实现这两个协议,SwiftUI 才知道如何进行插值计算。
Swfit 中的基础数据类型如整形、浮点型已实现 AdditiveArithmetic 协议,上面示例中的动画数据 controYFactor 就是浮点型,它已经实现了相应的协议。
但 controYFactor 是一个单一的可动画数据,如果现在想在这个基础上同时改变线条的两个端点在 y 轴上的位置。可以使用内置的结构体 AnimatablePair ,它已经实现了 VectorArithmetic 和 AdditiveArithmetic 协议,我们只需要将两个变量简单包装一下即可。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
fileprivate struct Line2 : Shape {
var controYFactor = 0.0
var pointYFactor = 0.0
var animatableData : AnimatablePair < Double , Double > {
get {
. init ( controYFactor , pointYFactor )
}
set {
controYFactor = newValue . first
pointYFactor = newValue . second
}
}
func path ( in rect : CGRect ) -> Path {
var path = Path ()
path . move ( to : . init ( x : 0 , y : rect . maxY * pointYFactor ))
path . addQuadCurve (
to : . init ( x : rect . maxX , y : rect . maxY * pointYFactor ),
control : . init ( x : rect . midX , y : rect . midY * controYFactor )
)
return path
}
}
自定义可动画数据
AnimatablePair 虽然使用方便但有局限性,它只适合比较简单的可动画数据。假设需要在 Line2 的基础上再添加一个可动画变量,AnimatablePair 虽然也可以实现,但显得乏力:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
var controYFactor : Double
var pointYFactor : Double
var pointXFactor : Double
var animatableData : AnimatablePair <
Double ,
AnimatablePair < Double , Double >
> {
get {
. init ( controYFactor , . init ( pointYFactor , pointXFactor ))
}
set {
controYFactor = newValue . first
pointYFactor = newValue . second . first
pointXFactor = newValue . second . second
}
}
更好的做法是将变量包装成一个结构体,将其作为可动画数据:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
fileprivate struct Line3 : Shape {
var lineData : LineData
var animatableData : LineData {
get { lineData }
set { lineData = newValue }
}
func path ( in rect : CGRect ) -> Path {
var path = Path ()
path . move ( to : . init (
x : rect . maxX * lineData . pointXFactor ,
y : rect . maxY * lineData . pointYFactor )
)
path . addQuadCurve (
to : . init (
x : rect . maxX * ( 1 - lineData . pointXFactor ),
y : rect . maxY * lineData . pointYFactor
),
control : . init (
x : rect . midX ,
y : rect . midY * lineData . controYFactor
)
)
return path
}
}
LineData 需要实现 VectorArithmetic 协议后,SwiftUI 才知道如何进行插值计算:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
struct LineData : VectorArithmetic {
var controYFactor : Double
var pointYFactor : Double
var pointXFactor : Double
static func + ( lhs : Self , rhs : Self ) -> Self {
. init (
controYFactor : lhs . controYFactor + rhs . controYFactor ,
pointYFactor : lhs . pointYFactor + rhs . pointYFactor ,
pointXFactor : lhs . pointXFactor + rhs . pointXFactor
)
}
static func - ( lhs : Self , rhs : Self ) -> Self {
. init (
controYFactor : lhs . controYFactor - rhs . controYFactor ,
pointYFactor : lhs . pointYFactor - rhs . pointYFactor ,
pointXFactor : lhs . pointXFactor - rhs . pointXFactor
)
}
static var zero : LineData {
. init ( controYFactor : 0 , pointYFactor : 0 , pointXFactor : 0 )
}
var magnitudeSquared : Double {
1.0
}
mutating func scale ( by rhs : Double ) {
controYFactor . scale ( by : rhs )
pointYFactor . scale ( by : rhs )
pointXFactor . scale ( by : rhs )
}
}
小结
动画其实是状态数据变化时,SwiftUI 在首尾状态之间不停地作插值运算,生成一系列重绘的视图。并非所有的数据是可动画的,只有实现了 VectorArithmetic 协议的数据才能让 SwiftUI 知道如何进行插值运算。Swift 中的基础数据类型如整形、浮点型,已经实现相应的协议,可以直接作为可动画数据。对于自定义数据类型,需要实现 VectorArithmetic 协议,才能实现动画效果。