您现在的位置: IOS教程網 >> IOS系統 >  >> iOS 程式開發 >> iOS 開發基礎

Swift 圖層實戰:CALayer 十個進階效果完整解析

編輯:iOS 開發基礎

作者: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 的基礎屬性

剛剛我們其實只動了 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 示例

CALayer 的屬性與方法多到用不完,還有幾個各自帶著專屬能力的子類別。要快速瀏覽這整套 API,Layer Player 這個示範 App 是最合適的導覽工具。

你需要的材料:

  • Layer Player App

  • Layer Player 原始碼

裡頭收錄了十個 CALayer 示例,接下來會逐一介紹:

建議一邊讀、一邊在 Layer Player 裡動手調參數,也翻翻對應的程式碼。不用打字,深呼吸,輕鬆讀就好。

希望這些示例能給你靈感,替自己的 App 加上一層不一樣的光彩。

示例 1:CALayer

前面已經玩過最基礎的 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。

示例 2:CAScrollLayer

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。

示例 3:CATextLayer

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 的屬性幾乎都能即時調整:

示例 4:AVPlayerLayer

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) }

逐步拆解:

  1. 建立播放器圖層並設定範圍。

  2. 用影音資源建立播放器。

  3. 指定播放結束後停止。其他選項還包括暫停或自動播放下一個媒體。

  4. 註冊播放結束的通知,並在 deinit 中移除觀察者,避免殘留。

  5. 按下播放鈕時切換播放狀態並更新按鈕文字。

這只是入門寫法,真實專案裡通常不會用文字按鈕控制播放。

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 一樣附了播放控制項:

示例 5:CAGradientLayer

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 裡,起終點、顏色與過渡點都能即時改:

示例 6:CAReplicatorLayer

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 中可調的項目:

示例 7:CATiledLayer

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   }   }

示例 8:CAShapeLayer

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 的入門教材。

示例 9:CATransformLayer

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 移植版)能讓你用簡單的手勢套用三維變換。

示例 10:CAEmitterLayer

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 之旅暫時告一段落。

但真正的開始在這之後:開一個新專案,或打開手邊的舊專案,試著用圖層把效能往上推一階,或替介面加上一點不一樣的視覺效果。這些屬性讀起來都懂,寫過一次才真的會。

  1. 上一篇文章:
  2. 下一篇文章:
蘋果刷機越獄教程| IOS教程問題解答| IOS技巧綜合| IOS7技巧| IOS8教程
Copyright © IOS教程網 All Rights Reserved