
作者:Scott Gardner 譯者:TurtleFromMars 原文:CALayer in iOS with Swift: 10 Examples
打開任何一個 iOS App,你看到的東西其實都是視圖(view):按鈕、表格、滑桿,還有裝著其他視圖的父視圖。
但很少人注意到,真正撐起每一個視圖的,是一個叫做「圖層」的類別——CALayer。視圖只是它的包裝,真正負責畫面的,是底下這層。
這篇文章會帶你搞懂 CALayer 的運作方式,並示範十種效果:從向量繪圖、漸層填色,一路玩到粒子系統。閱讀前請先具備 iOS 開發與 Swift 的基礎,並熟悉用 Storyboard 拉出基本介面。
如果基礎還不穩,也別急著跳過,先把 Swift 與 iOS 入門的教材補一補再回來,效果會好很多。
理解圖層最快的方式就是親手玩一次。我們從零開始建一個小專案。
準備好寫程式了嗎?開啟 Xcode,然後:
1. 選擇 File\New\Project。
2. 在對話框中選 iOS\Application\Single View Application。
3. 點 Next,Product Name 填 CALayerPlayground,再輸入自己的 Organization Name 與 Identifier。
4. Language 選 Swift,Devices 選 Universal。
5. 取消勾選 Core Data,點 Next。
6. 選一個合適的位置存檔(習慣上會放在使用者目錄下的 Source 資料夾),點 Create。
接著把視圖拉出來:
7. 在專案導覽器中打開 Main.storyboard。
8. 選 View\Assistant Editor\Show Assistant Editor;若沒看到物件庫,選 View\Utilities\Show Object Library。
9. 再選 Editor\Canvas\Show Bounds Rectangles,之後往場景裡放視圖時就能看見外框。
10. 從物件庫拖一個 View 進視圖控制器場景,保持選取狀態,在尺寸檢查器(View\Utilities\Show Size Inspector)中把 x、y 設為 150,Width 與 Height 設為 300。
11. 視圖保持選取,點右下角的 Align 按鈕,勾選 Horizontal Center in Container 與 Vertical Center in Container,數值都留 0,按 Add 2 Constraints。
12. 點 Pin 按鈕,勾選 Width 與 Height,數值都設 300,按 Add 2 Constraints。
最後按住 control 把視圖拖到 ViewController.swift 中 viewDidLoad() 上方,在彈出的視窗裡把 outlet 命名為 viewForLayer:

按 Connect 建立 outlet。
把 ViewController.swift 改成這樣:
import UIKit class ViewController: UIViewController { @IBOutlet weak var viewForLayer: UIView! var l: CALayer { return viewForLayer.layer } override func viewDidLoad() { super.viewDidLoad() setUpLayer() } func setUpLayer() { l.backgroundColor = UIColor.blueColor().CGColor l.borderWidth = 100.0 l.borderColor = UIColor.redColor().CGColor l.shadowOpacity = 0.7 l.shadowRadius = 10.0 } }iOS 裡每個視圖都有一個對應的圖層,透過 yourView.layer 就能取用。這段程式先開了一個小名為「l」(小寫 L)的計算屬性,讓後續寫圖層相關的程式時少打幾個字。
接著 setUpLayer 動手調整外觀:陰影、藍色背景、紅色粗邊框。現在先建置並在模擬器上跑起來(我用的是 iPhone 6),親眼看看自訂後的圖層長什麼樣子。

幾行程式,效果不差吧?既然每個視圖底下都有一層圖層,這套改寫法可以套用到 App 裡任何一個視圖上。繼續往下走。
剛剛我們其實只動了 CALayer 的四個屬性:
背景色從預設的透明改成藍色
邊框寬度從 0 改成 100,於是出現了邊框
邊框顏色從預設的黑改成紅
陰影透明度從 0(全透明)拉到 0.7,同時把陰影半徑從預設的 3 加大到 10
而這只是冰山一角。我們再追加兩行試試:
l.contents = UIImage(named: "star")?.CGImage l.contentsGravity = kCAGravityCenter
contents 屬性可以把圖層的內容直接設成一張圖片。這裡用一張星星圖,你需要先把圖片下載並加入專案。
建置、執行,欣賞成果:

星星置中,是因為 contentsGravity 被設成 kCAGravityCenter。顧名思義,這個屬性也能設成上、右上、右、右下、下、左下、左、左上等對齊位置。
純粹好玩,我們加兩個手勢辨識器來控制圖層外觀。先在 Xcode 中往 viewForLayer 上拖一個輕點手勢辨識器:

如果你對手勢辨識器還不熟,可以參考 Using UIGestureRecognizer with Swift。
同樣方式再拖一個縮放手勢辨識器(pinch gesture recognizer)。
接著按住 control,把兩個辨識器依序從 Storyboard 拖進 ViewController.swift,位置放在 setUpLayer() 之後、類別結尾大括號之前。
在彈窗中把連接方式改為 Action,輕點的命名為 tapGestureRecognized,縮放的命名為 pinchGestureRecognized:

把 tapGestureRecognized(_:) 改成:
@IBAction func tapGestureRecognized(sender: UITapGestureRecognizer) { l.shadowOpacity = l.shadowOpacity == 0.7 ? 0.0 : 0.7 }使用者輕點時,圖層的陰影透明度會在 0.7 與 0 之間來回切換。
你可能會想:為什麼不是直接改 CALayer?確實,改寫 CALayer 的 hitTest(_:) 也能達到同樣效果,後面也會碰到這個方法。但這裡選擇掛在視圖上有個務實的理由:圖層本身無法回應手勢辨識,只能處理 hit-test,所以手勢辨識器必須設在視圖上。
接著改 pinchGestureRecognized(_:):
@IBAction func pinchGestureRecognized(sender: UIPinchGestureRecognizer) { let offset: CGFloat = sender.scale < 1 ? 5.0 : -5.0 let oldFrame = l.frame let oldOrigin = oldFrame.origin let newOrigin = CGPoint(x: oldOrigin.x + offset, y: oldOrigin.y + offset) let newSize = CGSize(width: oldFrame.width + (offset * -2.0), height: oldFrame.height + (offset * -2.0)) let newFrame = CGRect(origin: newOrigin, size: newSize) if newFrame.width >= 100.0 && newFrame.width <= 300.0 { l.borderWidth -= offset l.cornerRadius += (offset / 2.0) l.frame = newFrame } }這裡依縮放手勢的正負方向算出位移量,同步調整圖層尺寸、邊框寬度與邊角半徑。
邊角半徑預設是 0,也就是標準的直角。數值加大就會出現圓角;若想讓圖層變成正圓,把半徑設成寬度的一半即可。
要注意:調整邊角半徑不會裁切圖層內容(那張星星圖),除非你把 masksToBounds 設為 true。
建置執行,試著在視圖上點一點、拉一拉:

仔細妝點一下,拿去當頭像都行了。
CALayer 的屬性與方法多到用不完,還有幾個各自帶著專屬能力的子類別。要快速瀏覽這整套 API,Layer Player 這個示範 App 是最合適的導覽工具。
你需要的材料:
Layer Player App
Layer Player 原始碼
裡頭收錄了十個 CALayer 示例,接下來會逐一介紹:

建議一邊讀、一邊在 Layer Player 裡動手調參數,也翻翻對應的程式碼。不用打字,深呼吸,輕鬆讀就好。
希望這些示例能給你靈感,替自己的 App 加上一層不一樣的光彩。

前面已經玩過最基礎的 CALayer,也就是設定各項屬性。關於它還有幾件事值得補充:
圖層可以擁有子圖層。就像視圖能包含子視圖,圖層也能層層嵌套,稍加運用就能做出漂亮的效果。
圖層屬性自帶動畫。改動屬性時預設就會有過渡動畫,而且行為可以自訂。
圖層比視圖輕量。同樣的畫面用圖層實作,通常更省資源、效能更好。
實用屬性非常多。前面才看了幾個,接下來繼續。
這段程式一次示範了一批常用屬性,有些你可能第一次看到,但真的很好用:
// 1 let layer = CALayer() layer.frame = someView.bounds // 2 layer.contents = UIImage(named: "star")?.CGImage layer.contentsGravity = kCAGravityCenter // 3 layer.magnificationFilter = kCAFilterLinear layer.geometryFlipped = false // 4 layer.backgroundColor = UIColor(red: 11/255.0, green: 86/255.0, blue: 14/255.0, alpha: 1.0).CGColor layer.opacity = 1.0 layer.hidden = false layer.masksToBounds = false // 5 layer.cornerRadius = 100.0 layer.borderWidth = 12.0 layer.borderColor = UIColor.whiteColor().CGColor // 6 layer.shadowOpacity = 0.75 layer.shadowOffset = CGSize(width: 0, height: 3) layer.shadowRadius = 3.0 someView.layer.addSublayer(layer)
逐段說明:
建立一個 CALayer,把範圍對齊 someView 的邊界。
把內容設成一張圖片並置中。注意這裡要給的是底層的 Quartz 影像資料(CGImage),不是 UIImage。
設定縮放時使用的過濾器。這個屬性會在圖片被 contentsGravity 放大時生效,可以控制放大方式(線性、比例縮放、填充比例縮放)與對齊位置。這兩個屬性的變動不會有動畫;另外若 geometryFlipped 沒有設為 true,幾何座標與陰影會上下顛倒。
背景設為深綠色,然後讓圖層不透明度為 1、可見。masksToBounds 設為 false 的意思是:當圖層比內容(星星圖)小時,圖片不會被裁掉。
邊角半徑設為寬度的一半,讓外緣變成正圓。這裡要注意顏色要給 Quartz 色彩參照(CGColor)。
加上陰影,並把圖層掛進視圖的階層結構中。
成果如下:

CALayer 另有兩個和效能有關的屬性:shouldRasterize 與 drawsAsynchronously。
shouldRasterize 預設為 false,設為 true 能提升效能,因為圖層內容只需算繪一次。對於會在畫面上移動、但外觀不變的物件,效果特別明顯。
drawsAsynchronously 預設也是 false,適用情境正好相反:當圖層內容需要反覆重繪時(例如大量粒子的發射器圖層,後面會看到 CAEmitterLayer),設為 true 可能會讓效能變好。
但請注意:把既有圖層的這兩個屬性改成 true 之前,一定要先實測比較。設不恰當不但沒有效果,反而可能讓效能大幅惡化。
回到示範 App,這裡有一組控制項可以直接調 CALayer 的屬性:

隨便拉一拉,感受一下 CALayer 能做出什麼。
補充一點:圖層不在回應鏈(responder chain)裡,沒辦法像視圖那樣直接接收觸碰與手勢,這點在 CALayerPlayground 已經看過了。不過圖層有 hit-test,後面的 CATransformLayer 會示範;想加自訂動畫,則可以參考 CAReplicatorLayer。
CAScrollLayer 顯示的是一個可捲動圖層的其中一部分。它非常基本:不會自行回應使用者的觸碰,也不檢查捲動邊界,所以不會出現無限捲動的失控狀況。
順帶一提,UIScrollView 用的其實不是 CAScrollLayer,而是直接改動圖層的邊界。
CAScrollLayer 的捲動方向可以設為水平、垂直或二維,捲動位置也能用程式指定:
// In ScrollingView.swift import UIKit class ScrollingView: UIView { // 1 override class func layerClass() -> AnyClass { return CAScrollLayer.self } } // In CAScrollLayerViewController.swift import UIKit class CAScrollLayerViewController: UIViewController { @IBOutlet weak var scrollingView: ScrollingView! // 2 var scrollingViewLayer: CAScrollLayer { return scrollingView.layer as CAScrollLayer } override func viewDidLoad() { super.viewDidLoad() // 3 scrollingViewLayer.scrollMode = kCAScrollBoth } @IBAction func tapRecognized(sender: UITapGestureRecognizer) { // 4 var newPoint = CGPoint(x: 250, y: 250) UIView.animateWithDuration(0.3, delay: 0, options: .CurveEaseInOut, animations: { [unowned self] in self.scrollingViewLayer.scrollToPoint(newPoint) }, completion: nil) } }程式碼在說什麼:
定義一個繼承 UIView 的子類別,改寫 layerClass() 回傳 CAScrollLayer。這等於指定這個視圖要用哪一種圖層,比手動建立子圖層(第一個示例的做法)更乾淨。
一個計算屬性,方便存取自訂視圖的捲動圖層。
把捲動模式設為二維。
偵測到輕點時,用 UIView 動畫把圖層捲到新的座標。要注意 scrollToPoint(_:) 與 scrollToRect(_:) 本身不帶動畫,得自己包一層。
如果 ScrollingView 裡放了一張比自身邊界大的圖片視圖,執行後點一下畫面會是這樣:

示範 App 裡還有鎖定捲動方向(水平或垂直)的開關可以試。
關於要不要用 CAScrollLayer,可以參考這幾條經驗法則:
想要輕量、純程式控制捲動:考慮 CAScrollLayer。
要讓使用者用手指操作捲動:UIScrollView 大概會更好。
要捲動超大圖片:請直接看後面的 CATiledLayer。
CATextLayer 能快速算繪純文字或屬性字串。和 UILabel 不同,它不吃 UIFont,必須改用 CTFontRef 或 CGFontRef。
下面這段程式示範了如何完全掌握字型、字級、顏色、對齊、換行與截斷規則,而且同樣帶有動畫效果:
// 1 let textLayer = CATextLayer() textLayer.frame = someView.bounds // 2 var string = "" for _ in 1...20 { string += "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Fusce auctor arcu quis velit congue dictum. " } textLayer.string = string // 3 let fontName: CFStringRef = "Noteworthy-Light" textLayer.font = CTFontCreateWithName(fontName, fontSize, nil) // 4 textLayer.foregroundColor = UIColor.darkGrayColor().CGColor textLayer.wrapped = true textLayer.alignmentMode = kCAAlignmentLeft textLayer.contentsScale = UIScreen.mainScreen().scale someView.layer.addSublayer(textLayer)說明:
建立 CATextLayer,範圍對齊 someView。
把一段文字重複串接成字串,指定給圖層。
建立字型物件並套用。
開啟換行、設為靠左對齊。對齊模式也可以選自然對齊(natural)、靠右(right)、置中(center)或左右對齊(justified)。最後依螢幕設定 contentsScale,再把圖層加入階層結構。
這裡有個容易忽略的細節:所有圖層的算繪縮放比例預設都是 1。圖層被加入視圖時,系統會自動幫它調整 contentsScale;但如果是你自己手動建立的圖層,就必須明確指定,否則預設值 1 會讓內容在 Retina 螢幕上顯得模糊。
把這個文字圖層放到方形的 someView 上,結果如下:

你還可以設定截斷(truncation),被截掉的部分會用省略符號表示。預設不截斷,位置可選開頭、結尾或中間:

示範 App 中,CATextLayer 的屬性幾乎都能即時調整:

AVPlayerLayer 是 AVFoundation 體系裡的實用圖層,內部持有一個 AVPlayer,用來播放影音媒體(AVPlayerItem):
override func viewDidLoad() { super.viewDidLoad() // 1 let playerLayer = AVPlayerLayer() playerLayer.frame = someView.bounds // 2 let url = NSBundle.mainBundle().URLForResource("someVideo", withExtension: "m4v") let player = AVPlayer(URL: url) // 3 player.actionAtItemEnd = .None playerLayer.player = player someView.layer.addSublayer(playerLayer) // 4 NSNotificationCenter.defaultCenter().addObserver(self, selector: "playerDidReachEndNotificationHandler:", name: "AVPlayerItemDidPlayToEndTimeNotification", object: player.currentItem) } deinit { NSNotificationCenter.defaultCenter().removeObserver(self) } // 5 @IBAction func playButtonTapped(sender: UIButton) { if playButton.titleLabel?.text == "Play" { player.play() playButton.setTitle("Pause", forState: .Normal) } else { player.pause() playButton.setTitle("Play", forState: .Normal) } updatePlayButtonTitle() updateRateSegmentedControl() } // 6 func playerDidReachEndNotificationHandler(notification: NSNotification) { let playerItem = notification.object as AVPlayerItem playerItem.seekToTime(kCMTimeZero) }逐步拆解:
建立播放器圖層並設定範圍。
用影音資源建立播放器。
指定播放結束後停止。其他選項還包括暫停或自動播放下一個媒體。
註冊播放結束的通知,並在 deinit 中移除觀察者,避免殘留。
按下播放鈕時切換播放狀態並更新按鈕文字。
這只是入門寫法,真實專案裡通常不會用文字按鈕控制播放。
AVPlayerLayer 會顯示 AVPlayerItem 的第一幀作為預覽:

它另有幾個好用的屬性:
videoGravity 決定影片的縮放方式。
readyForDisplay 用來判斷是否已準備好播放。
AVPlayer 這邊值得注意的則是 rate:0 代表暫停,1 代表正常速度播放。這個屬性和播放行為聯動——呼叫 pause() 等同把 rate 設為 0,play() 等同設為 1。
那快轉、慢動作和倒放呢?交給 rate 就好。大於 1 會以對應倍速播放(設 2 就是二倍速),設為負值則會以對應倍速倒放。
不過在以非常規速度播放之前,系統會先呼叫 AVPlayerItem 上的方法確認能力:
canPlayFastForward() 對應大於 1
canPlaySlowForward() 對應 0 到 1 之間
canPlayReverse() 對應 -1
canPlaySlowReverse() 對應 -1 到 0 之間
canPlayFastReverse() 對應小於 -1
實務上,大多數影片都支援各種正向播放速度,但支援倒放的相對少得多。示範 App 一樣附了播放控制項:

CAGradientLayer 把「混合兩種以上顏色」這件事簡化到幾行程式就能搞定,做背景特別合適。設定方式很單純:給它一個 CGColor 陣列,再指定起點 startPoint 與終點 endPoint。
這裡有個容易誤解的地方:startPoint 與 endPoint 不是實際座標,而是單位座標空間中的比例值,算繪時才映射到圖層邊界。也就是說 x 為 1 代表圖層右緣,y 為 1 代表下緣。
CAGradientLayer 有個 type 屬性,但目前只有 kCAGradientLayerAxial 一個選項,也就是沿線性方向做顏色過渡。
具體來說,漸層沿著 startPoint 指向 endPoint 的方向變化;把所有與這條向量垂直的直線拿來看,線上每一點的顏色都相同。

另外,locations 屬性可以傳入一個取值 0 到 1 的陣列,指定各過渡點落在 colors 的哪個位置。不設定的話,系統會平均分配。一旦設定,數量就必須和 colors 一致,否則會出錯。
建立漸層圖層的範例:
let gradientLayer = CAGradientLayer() gradientLayer.frame = someView.bounds gradientLayer.colors = [cgColorForRed(209.0, green: 0.0, blue: 0.0), cgColorForRed(255.0, green: 102.0, blue: 34.0), cgColorForRed(255.0, green: 218.0, blue: 33.0), cgColorForRed(51.0, green: 221.0, blue: 0.0), cgColorForRed(17.0, green: 51.0, blue: 204.0), cgColorForRed(34.0, green: 0.0, blue: 102.0), cgColorForRed(51.0, green: 0.0, blue: 68.0)] gradientLayer.startPoint = CGPoint(x: 0, y: 0) gradientLayer.endPoint = CGPoint(x: 0, y: 1) someView.layer.addSublayer(gradientLayer) func cgColorForRed(red: CGFloat, green: CGFloat, blue: CGFloat) -> AnyObject { return UIColor(red: red/255.0, green: green/255.0, blue: blue/255.0, alpha: 1.0).CGColor as AnyObject }這段程式建立了一個漸層圖層,範圍對齊 someView,指定顏色陣列與起終點,最後掛進視圖階層。成果如下:

繽紛得很有派頭。
示範 App 裡,起終點、顏色與過渡點都能即時改:

CAReplicatorLayer 能把一個圖層複製成指定的份數,用來做效果非常合適。每一份複製品都能有自己的顏色與位置,還能設定繪製延遲形成時間差,看起來就像動畫;再搭配深度資訊,甚至能做出三維感。
// 1 let replicatorLayer = CAReplicatorLayer() replicatorLayer.frame = someView.bounds // 2 replicatorLayer.instanceCount = 30 replicatorLayer.instanceDelay = CFTimeInterval(1 / 30.0) replicatorLayer.preservesDepth = false replicatorLayer.instanceColor = UIColor.whiteColor().CGColor // 3 replicatorLayer.instanceRedOffset = 0.0 replicatorLayer.instanceGreenOffset = -0.5 replicatorLayer.instanceBlueOffset = -0.5 replicatorLayer.instanceAlphaOffset = 0.0 // 4 let angle = Float(M_PI * 2.0) / 30 replicatorLayer.instanceTransform = CATransform3DMakeRotation(CGFloat(angle), 0.0, 0.0, 1.0) someView.layer.addSublayer(replicatorLayer) // 5 let instanceLayer = CALayer() let layerWidth: CGFloat = 10.0 let midX = CGRectGetMidX(someView.bounds) - layerWidth / 2.0 instanceLayer.frame = CGRect(x: midX, y: 0.0, width: layerWidth, height: layerWidth * 3.0) instanceLayer.backgroundColor = UIColor.whiteColor().CGColor replicatorLayer.addSublayer(instanceLayer) // 6 let fadeAnimation = CABasicAnimation(keyPath: "opacity") fadeAnimation.fromValue = 1.0 fadeAnimation.toValue = 0.0 fadeAnimation.duration = 1 fadeAnimation.repeatCount = Float(Int.max) // 7 instanceLayer.opacity = 0.0 instanceLayer.addAnimation(fadeAnimation, forKey: "FadeAnimation")
程式碼重點:
建立複製圖層,範圍對齊 someView。
設定複製份數 instanceCount 與繪製延遲,並關閉深度(preservesDepth = false)走 2D,實例顏色設為白色。
設定各複製品的 RGB 偏移量(預設 0,代表顏色不變)。因為實例起始色是白色(RGB 全為 1.0),所以把紅色偏移設 0、綠色與藍色設成相同的負值,顏色就會逐步偏向紅色。alpha 偏移的運作方式也一樣,都是逐份累加。
建立旋轉變換,讓複製品沿著一個圓均勻分布。
建立被複製的實例圖層,設定範圍讓第一份出現在 someView 頂端正中,指定顏色後加入複製圖層。
建立一個從不透明(1)淡出到全透明(0)的動畫。
把實例圖層的不透明度設為 0,讓每一份在算繪並套用顏色位移之前先保持透明。
做出來的效果是這樣:

示範 App 中可調的項目:

CATiledLayer 以「磚塊」(tile)為單位非同步算繪圖層內容,處理超大圖片或只需要顯示局部的場景特別有效——因為不必把整張圖載入記憶體,就能看到畫面。
最簡單的用法是改寫 UIView,讓它用 CATiledLayer 畫出背景:
// In ViewController.swift import UIKit class ViewController: UIViewController { // 1 @IBOutlet weak var tiledBackgroundView: TiledBackgroundView! } // In TiledBackgroundView.swift import UIKit class TiledBackgroundView: UIView { let sideLength = CGFloat(50.0) // 2 override class func layerClass() -> AnyClass { return CATiledLayer.self } // 3 required init(coder aDecoder: NSCoder) { super.init(coder: aDecoder) srand48(Int(NSDate().timeIntervalSince1970)) let layer = self.layer as CATiledLayer let scale = UIScreen.mainScreen().scale layer.contentsScale = scale layer.tileSize = CGSize(width: sideLength * scale, height: sideLength * scale) } // 4 override func drawRect(rect: CGRect) { let context = UIGraphicsGetCurrentContext() var red = CGFloat(drand48()) var green = CGFloat(drand48()) var blue = CGFloat(drand48()) CGContextSetRGBFillColor(context, red, green, blue, 1.0) CGContextFillRect(context, rect) } }說明:
tiledBackgroundView 位於 (150, 150),寬高各 300。
改寫 layerClass(),讓這個視圖使用 CATiledLayer。
設定 rand48() 的隨機種子,供 drawRect() 產生隨機色;把圖層轉型,依螢幕縮放調整內容比例與磚塊尺寸。
改寫 drawRect(),用隨機色填滿視圖。
這段程式畫出 6×6 的隨機色塊方格:

示範 App 還能在圖層背景上畫出軌跡:

但在視圖中放大時,星星那張圖就會開始模糊:

模糊的根源是圖層的細節層級(level of detail,LOD)。CATiledLayer 有兩個相關屬性:levelsOfDetail 與 levelsOfDetailBias。
levelsOfDetail 顧名思義,是圖層維護的 LOD 數量,預設為 1。每往上一級,就會額外快取前一級一半解析度的版本;最底層對應的是「至少還有一個像素」的細節程度。
levelsOfDetailBias 則是「放大方向」額外快取的層級數,預設 0,也就是不多存放大版本。每往上一級,會快取前一級兩倍解析度的內容。
舉例來說,把前面那個分塊圖層的 levelsOfDetailBias 設為 5,就會快取 2x、4x、8x、16x、32x 這幾個放大層級,放大後的效果變成:

不錯吧?但還沒結束。
CATiledLayer 更實用的本事是非同步繪製磚塊,例如在捲動視圖裡顯示一張超大圖片。使用者捲動時,得讓分塊圖層知道該畫哪些磚塊,程式要多寫一些,但換來的是明顯的效能提升,很值得。
示範專案中的 UIImage+TileCutter.swift 提供了一個 UIImage 延伸,靈感來自 Nick Lockwood 在《iOS Core Animation: Advanced Techniques》中使用的終端工具。它的工作是把原圖切成指定尺寸的方塊,並依行列命名,例如第三列第七列的磚塊名為 windingRoad62.png(索引從 0 起算)。

有了這些磚塊,就能自訂一個 UIView 子類別來繪製分塊圖層:
import UIKit class TilingViewForImage: UIView { // 1 let sideLength = CGFloat(640.0) let fileName = "windingRoad" let cachesPath = NSSearchPathForDirectoriesInDomains(.CachesDirectory, .UserDomainMask, true)[0] as String // 2 override class func layerClass() -> AnyClass { return CATiledLayer.self } // 3 required init(coder aDecoder: NSCoder) { super.init(coder: aDecoder) let layer = self.layer as CATiledLayer layer.tileSize = CGSize(width: sideLength, height: sideLength) } // 4 override func drawRect(rect: CGRect) { let firstColumn = Int(CGRectGetMinX(rect) / sideLength) let lastColumn = Int(CGRectGetMaxX(rect) / sideLength) let firstRow = Int(CGRectGetMinY(rect) / sideLength) let lastRow = Int(CGRectGetMaxY(rect) / sideLength) for row in firstRow...lastRow { for column in firstColumn...lastColumn { if let tile = imageForTileAtColumn(column, row: row) { let x = sideLength * CGFloat(column) let y = sideLength * CGFloat(row) let point = CGPoint(x: x, y: y) let size = CGSize(width: sideLength, height: sideLength) var tileRect = CGRect(origin: point, size: size) tileRect = CGRectIntersection(bounds, tileRect) tile.drawInRect(tileRect) } } } } func imageForTileAtColumn(column: Int, row: Int) -> UIImage? { let filePath = "\(cachesPath)/\(fileName)_\(column)_\(row)" return UIImage(contentsOfFile: filePath) } }重點:
三個屬性:磚塊邊長、原圖檔名、TileCutter 存放磚塊的快取路徑。
改寫 layerClass() 回傳 CATiledLayer。
在 init 中把視圖自身的圖層轉型為分塊圖層並設定磚塊大小。這裡不必設 contentsScale,因為是直接改視圖自己的圖層,而非手動建立子圖層。
改寫 drawRect(),依行列把各磚塊畫上去。
如此一來,一個等同原圖尺寸的視圖就能塞進捲動視圖裡:

多虧 CATiledLayer,5120 × 3200 的大圖捲起來也一樣順:

不過仔細看會發現,快速捲動時磚塊的繪製過程還看得出來。兩個改善方向:一是把磚塊切得更小(上例是 640 × 640);二是自訂 CATiledLayer 子類別,改寫 fadeDuration() 回傳 0,取消淡入:
class TiledLayer: CATiledLayer { override class func fadeDuration() -> CFTimeInterval { return 0.0 } }CAShapeLayer 用可縮放的向量路徑來繪製,速度比圖片快得多,還有個附加好處:不必再準備 1x、2x、3x 三套圖片資源。
它提供的屬性也很豐富:線寬、顏色、虛線樣式、線段接合方式、路徑是否閉合、閉合區域要填什麼顏色,全部都能自訂。
import UIKit class ViewController: UIViewController { @IBOutlet weak var someView: UIView! // 1 let rwColor = UIColor(red: 11/255.0, green: 86/255.0, blue: 14/255.0, alpha: 1.0) let rwPath = UIBezierPath() let rwLayer = CAShapeLayer() // 2 func setUpRWPath() { rwPath.moveToPoint(CGPointMake(0.22, 124.79)) rwPath.addLineToPoint(CGPointMake(0.22, 249.57)) rwPath.addLineToPoint(CGPointMake(124.89, 249.57)) rwPath.addLineToPoint(CGPointMake(249.57, 249.57)) rwPath.addLineToPoint(CGPointMake(249.57, 143.79)) rwPath.addCurveToPoint(CGPointMake(249.37, 38.25), controlPoint1: CGPointMake(249.57, 85.64), controlPoint2: CGPointMake(249.47, 38.15)) rwPath.addCurveToPoint(CGPointMake(206.47, 112.47), controlPoint1: CGPointMake(249.27, 38.35), controlPoint2: CGPointMake(229.94, 71.76)) rwPath.addCurveToPoint(CGPointMake(163.46, 186.84), controlPoint1: CGPointMake(182.99, 153.19), controlPoint2: CGPointMake(163.61, 186.65)) rwPath.addCurveToPoint(CGPointMake(146.17, 156.99), controlPoint1: CGPointMake(163.27, 187.03), controlPoint2: CGPointMake(155.48, 173.59)) rwPath.addCurveToPoint(CGPointMake(128.79, 127.08), controlPoint1: CGPointMake(136.82, 140.43), controlPoint2: CGPointMake(129.03, 126.94)) rwPath.addCurveToPoint(CGPointMake(109.31, 157.77), controlPoint1: CGPointMake(128.59, 127.18), controlPoint2: CGPointMake(119.83, 141.01)) rwPath.addCurveToPoint(CGPointMake(89.83, 187.86), controlPoint1: CGPointMake(98.79, 174.52), controlPoint2: CGPointMake(90.02, 188.06)) rwPath.addCurveToPoint(CGPointMake(56.52, 108.28), controlPoint1: CGPointMake(89.24, 187.23), controlPoint2: CGPointMake(56.56, 109.11)) rwPath.addCurveToPoint(CGPointMake(64.02, 102.25), controlPoint1: CGPointMake(56.47, 107.75), controlPoint2: CGPointMake(59.24, 105.56)) rwPath.addCurveToPoint(CGPointMake(101.42, 67.57), controlPoint1: CGPointMake(81.99, 89.78), controlPoint2: CGPointMake(93.92, 78.72)) rwPath.addCurveToPoint(CGPointMake(108.38, 30.65), controlPoint1: CGPointMake(110.28, 54.47), controlPoint2: CGPointMake(113.01, 39.96)) rwPath.addCurveToPoint(CGPointMake(10.35, 0.41), controlPoint1: CGPointMake(99.66, 13.17), controlPoint2: CGPointMake(64.11, 2.16)) rwPath.addLineToPoint(CGPointMake(0.22, 0.07)) rwPath.addLineToPoint(CGPointMake(0.22, 124.79)) rwPath.closePath() } // 3 func setUpRWLayer() { rwLayer.path = rwPath.CGPath rwLayer.fillColor = rwColor.CGColor rwLayer.fillRule = kCAFillRuleNonZero rwLayer.lineCap = kCALineCapButt rwLayer.lineDashPattern = nil rwLayer.lineDashPhase = 0.0 rwLayer.lineJoin = kCALineJoinMiter rwLayer.lineWidth = 1.0 rwLayer.miterLimit = 10.0 rwLayer.strokeColor = rwColor.CGColor } override func viewDidLoad() { super.viewDidLoad() // 4 setUpRWPath() setUpRWLayer() someView.layer.addSublayer(rwLayer) } }說明:
建立顏色、路徑與圖形圖層三個物件。
一步步畫出圖形圖層的路徑。老實說,手寫繪圖程式碼很枯燥,這時可以考慮 PaintCode 這類工具:用圖形介面把圖形畫出來,支援匯入既有的 SVG 與 PSD 檔,還能直接產生程式碼。
設定圖形圖層:路徑指向第二步畫好的 CGPath,填色用第一步建立的 CGColor,填滿規則設為非零(non-zero),也就是預設規則。
填滿規則一共兩種,另一種是奇偶(even-odd)。本例的圖形沒有相交路徑,兩種規則結果相同。
非零規則把由左到右的路徑記為 +1、由右到左記為 -1,把所有路徑值加總,若結果大於零就填滿該區域。
就結果而言,非零規則會填滿圖形內部的所有點。
奇偶規則則是數該區域被路徑交叉的次數,奇數才填。文字描述有點抽象,看圖比較快:
右圖中間那個五邊形被交叉了偶數次,所以留白;周圍每個三角形被交叉奇數次,因此填上了顏色。

呼叫繪製與設定程式碼,把圖層掛進視圖階層。
這段程式畫出的是 raywenderlich.com 的圖標:

順便看一下用 PaintCode 畫出來的樣子:

示範 App 中,CAShapeLayer 的屬性一樣可以自由調整:

補充:示範 App 裡的下一個示例我們先跳過,因為 CAEAGLLayer 已經有點年紀了。從 iOS 8 起,Metal 框架提供了更先進的 CAMetalLayer,有興趣可以參考 iOS 8 Metal 的入門教材。
CATransformLayer 和其他圖層最大的差別是:它不會把子圖層壓平,因此特別適合組出 3D 結構。基本上它是一個圖層容器,每個子圖層可以各自套用透明度與空間變換,而邊框寬度、顏色這類算繪屬性則會被忽略。
變換圖層本身不支援 hit-test,因為無法在觸碰點與平面座標空間之間建立對應關係;但其中的子圖層可以正常回應 hit-test。
import UIKit class ViewController: UIViewController { @IBOutlet weak var someView: UIView! // 1 let sideLength = CGFloat(160.0) var redColor = UIColor.redColor() var orangeColor = UIColor.orangeColor() var yellowColor = UIColor.yellowColor() var greenColor = UIColor.greenColor() var blueColor = UIColor.blueColor() var purpleColor = UIColor.purpleColor() var transformLayer = CATransformLayer() // 2 func setUpTransformLayer() { var layer = sideLayerWithColor(redColor) transformLayer.addSublayer(layer) layer = sideLayerWithColor(orangeColor) var transform = CATransform3DMakeTranslation(sideLength / 2.0, 0.0, sideLength / -2.0) transform = CATransform3DRotate(transform, degreesToRadians(90.0), 0.0, 1.0, 0.0) layer.transform = transform transformLayer.addSublayer(layer) layer = sideLayerWithColor(yellowColor) layer.transform = CATransform3DMakeTranslation(0.0, 0.0, -sideLength) transformLayer.addSublayer(layer) layer = sideLayerWithColor(greenColor) transform = CATransform3DMakeTranslation(sideLength / -2.0, 0.0, sideLength / -2.0) transform = CATransform3DRotate(transform, degreesToRadians(90.0), 0.0, 1.0, 0.0) layer.transform = transform transformLayer.addSublayer(layer) layer = sideLayerWithColor(blueColor) transform = CATransform3DMakeTranslation(0.0, sideLength / -2.0, sideLength / -2.0) transform = CATransform3DRotate(transform, degreesToRadians(90.0), 1.0, 0.0, 0.0) layer.transform = transform transformLayer.addSublayer(layer) layer = sideLayerWithColor(purpleColor) transform = CATransform3DMakeTranslation(0.0, sideLength / 2.0, sideLength / -2.0) transform = CATransform3DRotate(transform, degreesToRadians(90.0), 1.0, 0.0, 0.0) layer.transform = transform transformLayer.addSublayer(layer) transformLayer.anchorPointZ = sideLength / -2.0 applyRotationForXOffset(16.0, yOffset: 16.0) } // 3 func sideLayerWithColor(color: UIColor) -> CALayer { let layer = CALayer() layer.frame = CGRect(origin: CGPointZero, size: CGSize(width: sideLength, height: sideLength)) layer.position = CGPoint(x: CGRectGetMidX(someView.bounds), y: CGRectGetMidY(someView.bounds)) layer.backgroundColor = color.CGColor return layer } func degreesToRadians(degrees: Double) -> CGFloat { return CGFloat(degrees * M_PI / 180.0) } // 4 func applyRotationForXOffset(xOffset: Double, yOffset: Double) { let totalOffset = sqrt(xOffset * xOffset + yOffset * yOffset) let totalRotation = CGFloat(totalOffset * M_PI / 180.0) let xRotationalFactor = CGFloat(totalOffset) / totalRotation let yRotationalFactor = CGFloat(totalOffset) / totalRotation let currentTransform = CATransform3DTranslate(transformLayer.sublayerTransform, 0.0, 0.0, 0.0) let rotationTransform = CATransform3DRotate(transformLayer.sublayerTransform, totalRotation, xRotationalFactor * currentTransform.m12 - yRotationalFactor * currentTransform.m11, xRotationalFactor * currentTransform.m22 - yRotationalFactor * currentTransform.m21, xRotationalFactor * currentTransform.m32 - yRotationalFactor * currentTransform.m31) transformLayer.sublayerTransform = rotationTransform } // 5 override func touchesBegan(touches: NSSet, withEvent event: UIEvent) { if let location = touches.anyObject()?.locationInView(someView) { for layer in transformLayer.sublayers { if let hitLayer = layer.hitTest(location) { println("Transform layer tapped!") break } } } } override func viewDidLoad() { super.viewDidLoad() // 6 setUpTransformLayer() someView.layer.addSublayer(transformLayer) } }程式碼解析:
建立屬性:立方體邊長、六個面的顏色,以及那個變換圖層。
依序建立六個面,各自套用平移與旋轉後加入變換圖層,組出一個立方體;接著設定 z 軸錨點、旋轉整體角度,最後掛進視圖階層。
輔助程式碼:用來產生指定顏色的面,以及角度與弧度的轉換。在矩陣運算裡用弧度寫法,可讀性會好很多。
依指定的 x、y 位移量決定旋轉角度。注意這裡變換的對象是 sublayerTransform,也就是套用在其所有子圖層上。
監聽觸碰,逐一對子圖層做 hit-test,一旦命中就跳出迴圈,不必繼續往下找。
設定並加入變換圖層。
你可能會問:currentTransform.m## 是什麼?那是 CATransform3D 的矩陣元素。想弄懂這段矩陣運算,可以參考 Rich Turton 的三維變換教學,以及 Mark Pospesel 的矩陣入門專案。
在 250 × 250 的 someView 上執行,結果如下:

試著點一下立方體,主控台會印出「Transform layer tapped!」。
示範 App 中可以調整透明度;另外 Bill Dudney 的軌跡球工具(Swift 移植版)能讓你用簡單的手勢套用三維變換。

CAEmitterLayer 算繪的粒子是 CAEmitterCell 的實例。兩者都提供了調整算繪頻率、大小、形狀、顏色、速度與生命週期的屬性。
import UIKit class ViewController: UIViewController { // 1 let emitterLayer = CAEmitterLayer() let emitterCell = CAEmitterCell() // 2 func setUpEmitterLayer() { emitterLayer.frame = view.bounds emitterLayer.seed = UInt32(NSDate().timeIntervalSince1970) emitterLayer.renderMode = kCAEmitterLayerAdditive emitterLayer.drawsAsynchronously = true setEmitterPosition() } // 3 func setUpEmitterCell() { emitterCell.contents = UIImage(named: "smallStar")?.CGImage emitterCell.velocity = 50.0 emitterCell.velocityRange = 500.0 emitterCell.color = UIColor.blackColor().CGColor emitterCell.redRange = 1.0 emitterCell.greenRange = 1.0 emitterCell.blueRange = 1.0 emitterCell.alphaRange = 0.0 emitterCell.redSpeed = 0.0 emitterCell.greenSpeed = 0.0 emitterCell.blueSpeed = 0.0 emitterCell.alphaSpeed = -0.5 let zeroDegreesInRadians = degreesToRadians(0.0) emitterCell.spin = degreesToRadians(130.0) emitterCell.spinRange = zeroDegreesInRadians emitterCell.emissionRange = degreesToRadians(360.0) emitterCell.lifetime = 1.0 emitterCell.birthRate = 250.0 emitterCell.xAcceleration = -800.0 emitterCell.yAcceleration = 1000.0 } // 4 func setEmitterPosition() { emitterLayer.emitterPosition = CGPoint(x: CGRectGetMidX(view.bounds), y: CGRectGetMidY(view.bounds)) } func degreesToRadians(degrees: Double) -> CGFloat { return CGFloat(degrees * M_PI / 180.0) } override func viewDidLoad() { super.viewDidLoad() // 5 setUpEmitterLayer() setUpEmitterCell() emitterLayer.emitterCells = [emitterCell] view.layer.addSublayer(emitterLayer) } // 6 override func traitCollectionDidChange(previousTraitCollection: UITraitCollection?) { setEmitterPosition() } }逐段解析:
1. 建立粒子發射器圖層與粒子胞。
2. 設定發射器圖層:
提供隨機數種子,讓粒子胞的部分屬性(例如速度)能被隨機化。
依 renderMode 指定的順序,在圖層背景與邊界之上算繪粒子胞。渲染模式預設是無序(unordered),其他選項還包括最舊優先(oldest first)、最新優先(oldest last)、由後往前(back to front,依 z 軸位置),以及加色渲染(additive)。
由於發射器要反覆重繪大量粒子胞,把 drawsAsynchronously 設為 true 通常能提升效能。
最後透過輔助方法設定發射位置。這個例子很能說明 drawsAsynchronously 為什麼有效——粒子數量一大,同步算繪就會卡住整個畫面。
3. 這一段設定的東西最多:
把粒子胞的內容設成一張圖片(圖檔在示範專案中)。
指定初速與變異範圍 velocityRange。發射器會用前面設定的種子建立隨機數生成器,在「初值 ± 變異範圍」之間取值;其他以 Range 結尾的屬性也是同樣的隨機化規則。
顏色設為黑色,讓後續的變異效果有對比——如果基準色是白色,粒子會亮到過曝。
利用隨機範圍設定顏色變異,而「速度」類屬性(如 alphaSpeed)決定的是粒子在生命週期內的變化快慢。
接著指定粒子的分布範圍,這裡是一個完整的圓錐。spin 控制自轉,emissionRange 的弧度值決定粒子散布的空間角度。
lifetime 設為 1 秒(預設 0,代表粒子根本不會出現)。birthRate 同理,單位是每秒產生數量,預設也是 0,必須設成正數才看得到粒子。
最後是 x、y 加速度,這會影響已射出粒子的飛行軌跡。
4. 角度轉弧度的輔助方法,以及把發射位置設在視圖正中央。
5. 完成發射器與粒子胞的設定,把粒子胞掛到圖層上,再把圖層掛進視圖階層。
6. iOS 8 新增的方法,用來處理目前裝置形態集(trait collection)的變化,例如裝置旋轉。若對形態集不熟,可以參考 iOS 8 的相關教材。
終於寫完了。資訊量確實很大,但相信讀到這裡的你已經吸收得差不多了。
執行成果如下:

示範 App 中,這些屬性都能即時微調:


恭喜,十個示例與各個圖層子類別都看完了,這趟 CALayer 之旅暫時告一段落。
但真正的開始在這之後:開一個新專案,或打開手邊的舊專案,試著用圖層把效能往上推一階,或替介面加上一點不一樣的視覺效果。這些屬性讀起來都懂,寫過一次才真的會。