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

用 GPU 為圖像處理加速:從零開始寫 GLSL 著色器

編輯:iOS 開發基礎

Instagram、Snapchat、Photoshop——這些耳熟能詳的應用,本質上都在做同一件事:圖像處理。它既可以簡單到只是把一張彩色照片轉成灰階,也可以複雜到分析一整段影片,並在熙攘的人群裡鎖定某個特定的面孔。儘管功能天差地別,它們背後卻遵循著相同的脈絡:從創造到渲染。

無論在電腦還是手機上,處理圖像的方式有很多種,但目前為止效率最高的做法,是把運算交給圖形處理器,也就是我們常說的 GPU。你的手機裡其實藏著兩顆性格迥異的處理單元:CPU 是個什麼都得管的多面手,而 GPU 則專心把一件事做到極致——大規模並行地做浮點運算。而所謂的圖像渲染,歸根到底就是在即將呈現在視窗上的每一個像素上,反覆進行大量的浮點計算。

只要善用 GPU,手機上的圖像渲染能力就能提升成百上千倍。可以說,如果沒有 GPU 的參與,手機上那種即時的高清影片濾鏡效果簡直是天方夜譚。

著色器(shader)正是我們駕馭這股力量的工具。它是用類 C 的著色語言寫成的小程序。著色語言種類繁多,但如果你專注於 OS X 或 iOS 開發,那就該把精力放在 OpenGL 著色語言(GLSL)上。掌握了 GLSL 的思路之後,你也能輕鬆把它遷移到 Metal 這類更專用的語言。本文要介紹的概念,與 Core Image 裡自訂核心矩陣(custom kernel)的做法有不少相通之處,只是在語法上略有差異。

對新手來說,這套流程可能顯得有些令人生畏。這篇文章的目的,就是幫你補上撰寫圖像處理著色器所必需的基礎知識,並把你領上打造自己著色器的那條路。

什麼是著色器

我們不妨坐上時光機回溯一下,看看著色器究竟是什麼,又是如何走進我們的工作流程的。

如果你在 iOS 5 或更早的年代就開始做 iOS 開發,或許還記得 iPhone 上的 OpenGL 編程經歷過一次轉折:從 OpenGL ES 1.1 邁向了 OpenGL ES 2.0。

OpenGL ES 1.1 並不使用著色器,取而代之的是一套被稱為「固定功能管線」(fixed-function pipeline)的機制。它提供了一組固定的函數來在螢幕上渲染物件,而不是讓你寫一個獨立的程序去指揮 GPU。這種做法的侷限性很大,你幾乎做不出任何特殊效果。如果你好奇著色器究竟能給工程帶來多大的改變,不妨看看 Brad Larson 撰寫的那篇部落格,講述他如何用著色器取代固定函數,重構了 Molecules 這個應用。

OpenGL ES 2.0 引入了「可程式化管線」。它允許你打造自己的著色器,賦予你更強大的能力與更高的靈活性。

在 OpenGL ES 裡,你必須寫出兩種著色器:頂點著色器(vertex shader)與片段著色器(fragment shader)。這兩者構成了一個完整程式的兩半,缺一不可——想組出一個能運行的著色器程式,兩者都必須到場。

頂點著色器負責定義在二維或三維場景中,幾何圖形該如何被處理。所謂頂點,就是二維或三維空間中的一個點。在圖像處理的情境下,通常有四個頂點,各自對應圖像的一個角。頂點著色器會設定頂點的位置,並把位置、紋理座標這類參數傳遞給片段著色器。

接著,GPU 會調用片段著色器,在物件或圖片的每一個像素上進行計算,最終算出每個像素的最終顏色。圖片說到底,也不過是一堆數據的集合——文件裡記錄了每個像素的各個顏色分量以及透明度值。由於每個像素套用的算式都相同,GPU 便能以流水線的方式批次處理,效率自然更高。使用經過妥善最佳化的著色器在 GPU 上運算,其效率可以達到 CPU 用同樣方式處理的上百倍。

如何把東西渲染到螢幕上,從一開始就是讓 OpenGL 開發者頭疼的事。光是讓螢幕顯示出非黑色的畫面,就得寫上一大堆樣板程式碼和配置。開發者要跨過一個又一個的坑,而這些坑帶來的挫敗感,加上著色器測試方法的匱乏,讓不少人連嘗試的念頭都打消了。

所幸,過去幾年裡湧現的一些工具與框架,大大緩解了開發者面對著色器時的焦慮:

  • GPUImage

  • ShaderToy

  • Shaderific

  • Quartz Composer

接下來我要示範的每一個著色器範例,都取自開源框架 GPUImage。如果你對 OpenGL/OpenGL ES 場景該如何配置才能用著色器渲染感到好奇,可以去 clone 這個倉儲。我們不會深入探討如何搭建 OpenGL/OpenGL ES 環境,那超出了本文的範圍。

第一個著色器範例

頂點著色器

關於著色器的理論已經談得夠多了,我們來看一段真實專案裡的著色器程式。這是 GPUImage 中一個基礎的頂點著色器:

attribute vec4 position;   attribute vec4 inputTextureCoordinate; varying vec2 textureCoordinate; void main()   {     gl_position = position;     textureCoordinate = inputTextureCoordinate.xy; }

我們逐行拆解:

attribute vec4 position;

和所有語言一樣,著色語言的設計者也為常見的型別量身打造了專屬的資料型別,比如二維與三維座標。這些型別被稱為向量,稍後我們會深入探討。回到應用程式的程式碼:我們建立了一組頂點,為每個頂點提供的其中一個參數,就是它在畫布上的位置。接著我們得告訴頂點著色器,它需要接收這個參數,因為稍後要用它來做些事情。由於這是一段 C 語言風格的程式,別忘了每行結尾都要加分號——如果你平常寫 Swift,得把這個習慣重新撿回來。

attribute vec4 inputTextureCoordinate;

這時你可能會納悶:我們不是已經拿到頂點位置了嗎,為什麼還需要一個紋理座標?難道它們不是同一樣東西?

其實未必。紋理座標是紋理映射(texture mapping)的一部分,當你想對紋理施加某種濾鏡效果時就會用到它。左上角座標是 (0,0),右上角是 (1,0)。如果我們要在圖片內部而非邊緣取一個紋理座標,那麼在應用中設定的值就會不同,例如 (.25, .25) 代表的就是從左上角往右、往下各移動圖片寬高四分之一的位置。在我們目前的圖像處理應用裡,我們希望紋理座標與頂點位置保持一致,因為要覆蓋整張圖片的長與寬。但有時候你會希望兩者不同,所以要牢記:它們並非註定相同。在這個範例中,頂點座標空間從 -1.0 延伸到 1.0,而紋理座標則從 0.0 到 1.0。

varying vec2 textureCoordinate;

由於頂點著色器肩負著與片段著色器溝通的職責,我們需要建立一個變數來和它共享資訊。在圖像處理裡,片段著色器唯一需要的相關資訊,就是頂點著色器此刻正在處理哪個像素。

gl_Position = position;

gl_Position 是一個內建變數。GLSL 提供了若干內建變數,稍後在片段著色器的例子裡我們還會見到另一個。這些特殊變數是可程式化管線的一部分,API 會主動去找它們,並知道該如何關聯。在這裡,我們指定了頂點的位置,並把它從程式中回傳給渲染管線。

textureCoordinate = inputTextureCoordinate.xy;

最後,我們取出這個頂點紋理座標的 X 與 Y 分量。我們只在意 inputTextureCoordinate 的前兩個參數,也就是 X 和 Y。這個座標最初以四個屬性的形式存在於頂點著色器中,但我們只需要其中兩個。我們把需要的屬性取出來,賦值給一個將與片段著色器溝通的變數,而不是一股腦把更多屬性丟給它。

在大多數圖像處理程式裡,頂點著色器都大同小異,所以接下來我們把焦點放在片段著色器上。

片段著色器

看完簡潔的頂點著色器,我們再來瞧一個能實現的最簡單片段著色器——一個直通(passthrough)濾鏡:

varying highp vec2 textureCoordinate; uniform sampler2D inputImageTexture; void main()   {     gl_FragColor = texture2D(inputImageTexture, textureCoordinate); }

這個著色器實際上不會改動圖像的任何東西。它是個直通著色器,意思是每個像素進去、原封不動地出來。我們逐行來看:

varying highp vec2 textureCoordinate;

由於片段著色器作用在每一個像素上,我們需要一個辦法確定此刻正在分析哪個像素/片段,也就是要存下它的 X 與 Y 座標。我們接收到的是先前在頂點著色器中設定好的紋理座標。

uniform sampler2D inputImageTexture;

為了處理圖像,我們從應用中接收一個圖片的參照,並把它當作二維紋理。這個資料型別叫 sampler2D,因為我們要從這個二維紋理中「取樣」出一個點來處理。

gl_FragColor = texture2D(inputImageTexture, textureCoordinate);

這是我們遇到的第一個 GLSL 專屬方法:texture2D。顧名思義,它負責取樣一個二維紋理。它接收我們先前宣告的屬性作為參數,據此決定被處理像素的顏色。這個顏色隨後被賦值給另一個內建變數 gl_FragColor。既然片段著色器的唯一使命就是確定一個像素的顏色,那麼 gl_FragColor 實質上就是我們片段著色器的「回傳語句」。一旦這個片段的顏色被設定,後續程式碼都不再需要執行——你在它之後寫的任何語句都不會被跑。

如你所見,寫著色器很大一部分功夫,就在於熟悉這門著色語言。即使它以 C 為基礎,仍潛藏著不少與普通 C 截然不同的古怪之處與細微差別。

GLSL 資料型別與運算

各式著色器都是用 OpenGL 著色語言(GLSL)寫成的。GLSL 是一種從 C 簡化而來的語言,它捨去了 C 的高階功能,例如動態記憶體管理;但同時也內建了一些在著色運算中常用的數學函數。

負責 OpenGL 與 OpenGL ES 標準的 Khronos 小組網站上,有不少實用參考資料。在你動手之前,最值得做的一件事,就是拿一份 OpenGL 與 OpenGL ES 的速查表:

  • OpenGL ES

  • OpenGL

翻閱這些速查卡,你就能快速掌握撰寫 OpenGL 應用時所需的著色語言函數與資料型別。

早用,常用。

即便在這麼簡單的著色器裡,也有些地方看起來頗為古怪,不是嗎?既然基礎著色器已經看過,是时候解釋其中一些設計,以及它們為何存在於 GLSL 之中。

輸入、輸出與精度修飾(Precision Qualifiers)

回頭看我們的直通著色器,你會發現一個變數標記為 varying,另一個標記為 uniform。

這些就是 GLSL 中的輸入與輸出,它們讓資料得以從應用流入,並在頂點著色器與片段著色器之間往返。

在 GLSL 裡,實際上有三種標籤可以賦予變數:

  • Uniforms

  • Attributes

  • Varyings

Uniforms 是外界與著色器溝通的橋樑,專為那些在一次渲染循環中保持不變的輸入值而設計。舉例來說,當你套用一個茶色濾鏡,並已經設定了濾鏡強度,那麼這些在一次渲染過程中不會變動的東西,就可以作為 Uniform 傳入。Uniform 在頂點著色器和片段著色器中都能被存取。

Attributes 只能在頂點著色器中存取。Attribute 是隨著每個頂點不同而變化的輸入值,例如頂點位置與紋理座標。頂點著色器利用這些變數計算出位置,據此得出一些值,再以 varyings 的形式傳給片段著色器。

最後,同樣重要的是 varyings 標籤。Varying 同時出現在頂點著色器與片段著色器中,用來在兩者之間傳遞資訊,且必須在兩處使用相同的名稱。數值在頂點著色器中被寫入 varying,再在片段著色器中被讀出。寫入 varying 的值,到了片段著色器會以插值的形式,填入兩個頂點之間的每個像素。

回望我們先前寫的簡易著色器,頂點著色器與片段著色器都用 varying 宣告了 textureCoordinate。我們在頂點著色器中寫入它,再把它傳進片段著色器,在那裡讀取並處理。

在我們繼續之前,還有最後一點要留意。看看這些變數的宣告,你會發現紋理座標帶了一個叫 highp 的標記。這個標記用來設定變數的精度。由於 OpenGL ES 是為運算能力有限的系統量身打造,加入精度限制可以換來效率的提升。

如果不需要太高的精度,你可以放寬設定,這或許能讓處理器在一個時鐘週期內消化更多數值。反過來說,像紋理座標這種地方,我們要盡可能確保精確,所以才明確要求更高的精度。

精度修飾之所以存在於 OpenGL ES,是因為它被設計用於行動裝置;而在舊版本的桌面 OpenGL 中並沒有這東西。由於 OpenGL ES 實際上是 OpenGL 的子集,你幾乎總能把 OpenGL ES 的專案直接移植到 OpenGL。但如果你要這麼做,記得把桌面版著色器裡的精度修飾拿掉。這一點至關重要,尤其是當你打算在 iOS 與 OS X 之間搬運專案時。

向量

在 GLSL 中,你會大量使用向量與向量型別。向量是個有點棘手的話題,它們表面看起來很直觀,但由於用途繁多,實際使用時常讓人犯迷糊。

在 GLSL 的語境裡,向量是一種類似陣列的特別資料型別,每種類型能容納固定數量的元素。深入鑽研的話,你甚至能查到每個元素確切的型別。不過在大多數情況下,直接用通用的向量型別就夠了。

有三種向量型別你會時常打交道:

  • vec2

  • vec3

  • vec4

這些向量型別各自裝著固定數量的浮點數:vec2 裝兩個,vec3 裝三個,vec4 裝四個。

它們可以用來承載著色器中各種需要保存或改變的資料。在片段著色器中,最直觀的就是 X 與 Y 座標——用 vec2 來存再合適不過。而在圖像處理中,另一個你得時時盯著的,就是每個像素的 R、G、B、A 值,這些用 vec4 來裝剛剛好。

矩陣

了解了向量,接著來認識矩陣。矩陣與向量頗為相似,只是又多加了一層複雜度:矩陣是「浮點數陣列的陣列」,而非單純的一維浮點數陣列。

和向量一樣,你會經常碰到的矩陣型別是:

  • mat2

  • mat3

  • mat4

vec2 存兩個浮點數,而 mat2 則能存下相當於兩個 vec2 的資料。往矩陣裡傳值時,並不強制一定要用向量,只要有足夠的浮點數把矩陣填滿即可。以 mat2 為例,你要么傳兩個 vec2,要么傳四個浮點數。由於你可以替向量命名,而且相較於直接丟四個浮點數,管理兩個物件顯然更省心,所以我非常建議用封裝好的向量來存資料,這樣更好追蹤。到了 mat4 就更複雜了,因為你得應付 16 個數字,而不是 4 個。

回到 mat2 的例子,我們有兩個 vec2 物件,每個 vec2 代表一行,而每個 vec2 的第一個元素代表一列。組裝矩陣時,務必確保每個值都落在正確的行與列上,否則拿它去運算,結果必然會出錯。

既然我們既有了矩陣,也有了填滿矩陣的向量,問題來了:「我們能用它們做什麼?」我們可以拿來存點、存顏色或別的資訊,但能不能透過修改它們,玩出一些漂亮的花樣呢?

向量與矩陣運算,也就是初等的線性代數

我見過關於線性代數與矩陣如何運作的最佳講解,來自一個網站。從那裡我借來一句頗有意思的調侃:

線性代數課程的倖存者,最後都成了物理學家、圖形程式員,或者其他形式的自虐狂。

矩陣運算整體來說並不「難」,問題在於它總是缺乏上下文的鋪墊,讓人難以從概念上理解究竟為什麼要跟它們打交道。我希望在交代一些它們在圖形編程中的應用背景之後,我們能領悟它們如何幫助我們創造不可思議的效果。

線性代數的妙處,在於能讓你一次對一大批數值進行運算。想像你有一組數字,想把每個都乘以 2。一般直覺是一個接一個地算,但既然每個數套用的都是同一套操作,那完全可以並行處理。

我們舉個乍看之下頗唬人的例子:CGAffineTransform。所謂仿射轉換,其實是很單純的操作,能改變那些帶有平行邊的圖形(比如正方形或矩形)的大小、位置或旋轉角度。

遇到這種情況,你當然可以坐下來,拿出紙筆親手推導這些轉換,但這麼做其實沒什麼意義。GLSL 內建了大量函數來代勞這些繁瑣的轉換計算,真正要緊的,是理解這些函數背後的思路。

GLSL 專屬函數

本文不會把 GLSL 的所有內建函數都梳理一遍,不過你可以在 Shaderific 上找到很不錯的相關資源。許多 GLSL 函數都是從 C 標準數學庫裡的基礎運算衍生而來,所以再花篇幅解釋 sin 函數是做什麼的,簡直是浪費時間。我們把重點放在幾個較為冷門的函數上,藉此說明該如何榨乾 GPU 的效能。

step():GPU 有個天生的弱點——它不太擅長處理條件邏輯。GPU 最愛做的事,是接收一串操作,然後把它們一股腦套用到所有東西上。分支會在片段著色器上帶來明顯的性能下滑,在行動裝置上尤其顯著。step() 提供了一種折衷:讓你在不產生分支的前提下實現條件邏輯。如果傳進 step() 的值小於閾值,它回傳 0.0;若大於或等於閾值,則回傳 1.0。把這個結果和著色器中的值相乘,就能決定該值是被採用還是被忽略,全程不必動用 if()。

mix():mix 函數能把兩個值(比如兩個顏色)混合成一個。如果我們手上有紅、綠兩種顏色,就能用 mix() 做線性插值。這在圖像處理中應用廣泛,例如透過一組參數來控制效果強弱。

clamp():GLSL 有個一貫的偏好,就是喜歡用歸一化的座標,它期望收到的顏色分量或紋理座標都落在 0.0 到 1.0 之間。為了防止數值不小心衝出這個狹窄的區間,我們可以用 clamp() 來把關。它會檢查並確保你的值待在 0.0 到 1.0 之間:若小於 0.0,就設成 0.0。這能攔下不少常見的錯誤,例如計算時不慎傳入負數,或其他完全超出算式範圍的值。

更複雜的著色器範例

我知道這一波數學攻勢大概快把你淹沒了。如果你還跟得上,我想舉幾個優雅的著色器例子,那會更有意思——當然,也讓你有機會再一次沉醉在 GLSL 的浪潮裡。

飽和度調整

這是一個用來調整飽和度的片段著色器,出自《圖形著色器:理論與實踐》一書。我強烈推薦所有對著色器有興趣的人讀一讀這本書。

飽和度,用來描述顏色的鮮豔與強烈程度。一件亮紅色的毛衣,飽和度遠高於北京霧霾時那片灰濛濛的天空。

在這個著色器裡,我們可以依據人類感知顏色與亮度的機制,做一些巧妙的優化。一般來說,人眼對亮度的敏感度遠高於對顏色的敏感度。多年來,壓縮軟體一個常見的優化思路,就是設法減少儲存顏色所佔的空間。

人不僅對亮度比對顏色更敏感,在同等亮度下,我們對某些特定顏色也更為靈敏,尤其是綠色。這意味著,當你想方設法壓縮圖片,或以某種方式改動它們的亮度與顏色時,多花些心思在綠色光譜上是明智之舉,因為我們的視覺對它最為敏感。

varying highp vec2 textureCoordinate; uniform sampler2D inputImageTexture;   uniform lowp float saturation; const mediump vec3 luminanceWeighting = vec3(0.2125, 0.7154, 0.0721); void main()   {    lowp vec4 textureColor = texture2D(inputImageTexture, textureCoordinate);    lowp float luminance = dot(textureColor.rgb, luminanceWeighting);    lowp vec3 greyScaleColor = vec3(luminance);     gl_FragColor = vec4(mix(greyScaleColor, textureColor.rgb, saturation), textureColor.w); }

我們逐行拆解這段片段著色器:

varying highp vec2 textureCoordinate; uniform sampler2D inputImageTexture;   uniform lowp float saturation;

再一次,因為這是個要與基礎頂點著色器溝通的片段著色器,我們需要宣告輸入紋理座標與輸入圖片紋理的 varying 變數,才能收到處理所需的資訊。這回多了一個要應付的新 uniform 變數——飽和度。飽和度是我們從使用者介面設定的一個參數,我們得知道使用者想要多少飽和度,才能呈現出相應的色彩。

const mediump vec3 luminanceWeighting = vec3(0.2125, 0.7154, 0.0721);

這裡我們建立一個三元素向量,為亮度計算保存各顏色的權重。這三個值相加必須等於 1,如此一來算出的亮度才會落在 0.0 到 1.0 之間。注意中間那個值,也就是代表綠色的權重,佔了約 70%,而藍色只分到它的十分之一。藍色對視覺的貢獻本來就不突出,把更多權重押在綠色上,確實有道理。

lowp vec4 textureColor = texture2D(inputImageTexture, textureCoordinate);

我們需要依據特定像素在圖片/紋理中的座標取樣,取得它的顏色資訊。這一次我們不打算像直通濾鏡那樣原樣回傳,而是要動動手腳。

lowp float luminance = dot(textureColor.rgb, luminanceWeighting);

這行程式碼,對沒學過線性代數、或是很久以前在學校學過卻幾乎沒再用過的人來說,可能看著有點陌生。我們在這裡使用了 GLSL 的點積運算。如果你還記得學校裡曾用點乘把兩個數字相乘,那麼就不難理解它在做什麼。點積以承載顏色資訊的 vec4 為參數,丟掉最後一個用不上的分量,把它與對應的亮度權重相乘,再把三個乘積加總,算出這個像素的綜合亮度。

lowp vec3 greyScaleColor = vec3(luminance);

我們建立一個三個分量都是亮度的 vec3。如果你只給一個值,編譯器會貼心地幫你把向量的每個分量都填成這個值。

gl_FragColor = vec4(mix(greyScaleColor, textureColor.rgb, saturation), textureColor.w);

最後,我們把所有片段拼湊起來。要決定每個新顏色是什麼,我們祭出剛學會的利器 mix 函數。它把剛算好的灰階值、原始的紋理顏色,以及使用者設定的飽和度資訊糅合在一起。

這就是一個相當實用的著色器——主函數裡短短四行,就能把圖片在彩色與灰色之間自由切換。挺不錯,對吧?

球形折射

最後,我們來欣賞一個漂亮的濾鏡,你可以拿它去向朋友炫耀,或是唬唬你的對手。它看起來就像有一顆玻璃球扣在你的圖片上。這一個乍看比前面的複雜,但我相信我們能拿下它。

varying highp vec2 textureCoordinate; uniform sampler2D inputImageTexture; uniform highp vec2 center;   uniform highp float radius;   uniform highp float aspectRatio;   uniform highp float refractiveIndex; void main()   {     highp vec2 textureCoordinateToUse = vec2(textureCoordinate.x, (textureCoordinate.y * aspectRatio + 0.5 - 0.5 * aspectRatio));     highp float distanceFromCenter = distance(center, textureCoordinateToUse);     lowp float checkForPresenceWithinSphere = step(distanceFromCenter, radius);     distanceFromCenter = distanceFromCenter / radius;     highp float normalizedDepth = radius * sqrt(1.0 - distanceFromCenter * distanceFromCenter);     highp vec3 sphereNormal = normalize(vec3(textureCoordinateToUse - center, normalizedDepth));     highp vec3 refractedVector = refract(vec3(0.0, 0.0, -1.0), sphereNormal, refractiveIndex);     gl_FragColor = texture2D(inputImageTexture, (refractedVector.xy + 1.0) * 0.5) * checkForPresenceWithinSphere; }

再一次,看著有點眼熟……

uniform highp vec2 center;   uniform highp float radius;   uniform highp float aspectRatio;   uniform highp float refractiveIndex;

我們引入了一些參數,用來框定圖片中多大的區域要套用濾鏡。既然它是個球,我們就需要一個圓心與半徑來算出邊界。寬高比取決於裝置的螢幕尺寸,因此不能寫死,因為 iPhone 與 iPad 的比例並不相同。折射率則交由使用者或程式員決定,用來控制折射的觀感。在 GPUImage 中,折射率被設為 0.71。

highp vec2 textureCoordinateToUse = vec2(textureCoordinate.x, (textureCoordinate.y * aspectRatio + 0.5 - 0.5 * aspectRatio));

圖片的紋理座標落在歸一化的 0.0–1.0 座標空間裡。所謂歸一化,就是把螢幕看作一單位寬、一單位長,而不是具體的 320 像素寬、480 像素高。由於手機的高度往往大於寬度,我們需要為球形算出一個偏移量,這樣球才是正圓,而不會被拉成橢圓。

highp float distanceFromCenter = distance(center, textureCoordinateToUse);

我們需要算出某個特定像素離球心有多遠。這裡動用 GLSL 內建的 distance() 函數,它會以勾股定理求出圓心與經寬高比校正後的紋理座標之間的距離。

lowp float checkForPresenceWithinSphere = step(distanceFromCenter, radius);

在這裡,我們判斷某個片段是否落在球體之內。我們算出當前點到球心的距離,再和半徑相比。若當前距離小於半徑,這個片段就在球內,變數被設為 1.0;否則,若距離大於半徑,片段就在球外,變數被設為 0.0。

distanceFromCenter = distanceFromCenter / radius;

既然已經算出哪些像素落在球內,接下來就要對這些球內像素動手。這裡我們需要把到球心的距離標準化。我們直接覆寫 distanceFromCenter,而不另開一個新變數,因為那樣會增加開銷。把它除以半徑之後,後面幾行的計算會清爽許多。

highp float normalizedDepth = radius * sqrt(1.0 - distanceFromCenter * distanceFromCenter);

因為我們想模擬一顆玻璃球,所以得算出這個球的「深度」。這個虛擬的球,會沿著 Z 軸,從圖片表面向觀察者方向延伸出去。這能幫助電腦決定該如何呈現球內的像素。而且,由於球是圓的,離球心遠近不同,深度也不同——球心與邊緣處的表面朝向各異,對光的折射自然就不一樣:

highp vec3 sphereNormal = normalize(vec3(textureCoordinateToUse - center, normalizedDepth));

這裡我們又做了一次歸一化。為了算出球面上某點的朝向,我們先用 X、Y 座標表示當前像素到球心的偏移,再把它與剛算出的球深度組合起來,最後將結果向量歸一化。

想想你在用 Adobe Illustrator 這類軟體時的場景:你畫了一個三角形,但它太小了;你按住 option 鍵放大,結果又太大了;於是你再把它縮回理想的尺寸:

highp vec3 refractedVector = refract(vec3(0.0, 0.0, -1.0), sphereNormal, refractiveIndex);

refract() 是個相當有意思的 GLSL 函數。它拿我們剛建好的球法線與折射率,算出光線穿過這樣一顆球時,從球面上任意一點看出去該是什麼模樣。

gl_FragColor = texture2D(inputImageTexture, (refractedVector.xy + 1.0) * 0.5) * checkForPresenceWithinSphere;

終於,在闖過這一道道關卡之後,我們湊齊了計算片段顏色所需的一切資訊。折射向量用來定位該去圖片的哪個位置取樣,但由於那個向量裡的座標是從 -1.0 到 1.0,我們得把它調整回 0.0–1.0 的紋理座標空間。

接著,我們把結果與球邊界檢查的值相乘。如果片段不在球內,一個透明像素 (0.0, 0.0, 0.0, 0.0) 就會被寫入;若片段在球內,則採用計算好的顏色。如此一來,我們便在著色器中避開了昂貴的條件邏輯。

除@interface 著色器

除@interface 著色器絕非一件直觀的事。在普通程序裡,程式崩潰了,你大可下一個斷點;但在一秒內被並行調用上幾百萬次的運算面前,這招根本行不通。想用 printf() 打印除@interface 資訊?問題是——輸出到哪裡去呢?你的著色器就像跑在一個黑盒子裡,你該如何打開它,看看它為什麼不聽話?

你手上其實有一個可用的出口:我們的老朋友 gl_FragColor。換個思路,你可以拿它來除@interface 自己的程式。

螢幕上你看到的所有顏色,本質上都是一串數字,代表著每個像素紅、綠、藍與透明度的百分比。掌握了這點,你就能檢驗著色器的每一段是否如你所構想的那樣運作。與一般除@interface 不同,你拿到的不是一個能直接打印的值,而是一種顏色,以及與之對應的某個數值,靠著它逆向反推。

假設你想知道某個介於 0 和 1 之間的值,可以把它塞進一個將傳入 gl_FragColor 的 vec4 裡。比方說你把它放進第一部分,也就是紅色分量。這個值會被轉換並渲染到螢幕上,你就能藉此判斷當初傳進去的究竟是什麼。

捕捉這些值有幾種途徑。從著色器輸出的圖片,可以被擷取下來,以圖片形式寫入磁碟(最好用未經壓縮的格式)。這張圖之後可以丟進 Photoshop 這類軟體,逐一檢查像素的顏色。

若想更快一些,你可以把圖片用 OS X 程式或 iOS 模擬器顯示在螢幕上。在你應用程式的檔案夾裡,實用工具分類下藏著一個「數碼測色計」(Digital Color Meter),可以用來分析這些渲染後的畫面。把游標移到桌面上的任一像素,它就會精確顯示該點的 RGB 值。由於 RGB 在數碼測色計與 Photoshop 中是 0 到 255,而非 0 到 1,你得把想要的值除以 255,才能還原出近似於輸入的值。

回顧一下我們的球形折射著色器。簡直無法想像,若不做任何測試,怎么可能一口氣寫出整個程式。我們有一大段程式碼專門判斷當前像素是否落在那個圓裡,而那段程式碼的收尾,正是用 step() 把這個值設成 0.0 或 1.0。

把一個 vec4 的紅色分量設為 step() 的輸出,另外兩個顏色分量設為 0,再傳進 gl_FragColor。如果你的程式運作正常,你會在一片漆黑中看到一個紅色的圓。要是整個螢幕全黑、或全紅,那必然是某處出了差錯。

性能調優

效能測試與調優至關重要,尤其是當你希望應用在舊款 iOS 裝置上也能流暢運行時。

測試著色器效能之所以關鍵,是因為你往往無法預判一段程式碼的表現。著色器的效能變化頗不直觀:你會發現 Stack Overflow 上某個廣受好評的最佳化方案,套到你這裡卻絲毫沒有加速效果,因為你根本沒打到真正的瓶頸。哪怕只是調換專案裡的幾行程式碼,都可能讓渲染時間大幅增減。

分析時,我建議測量「幀渲染時間」,而不是「每秒渲染多少幀」。幀渲染時間會隨著著色器效能線性地增減,讓你更容易觀察自己的改動帶來了什麼。FPS 是幀時間的倒數,在調優時往往不易理解。此外,如果你用 iPhone 的相機捕捉影像,它會依場景亮度自動調整 FPS,一旦你依賴這個數字,就會導致測量失準。

所謂幀渲染時間,指的是一幀從開始處理,到徹底完成並渲染上螢幕或寫入圖片所花的時間。許多行動 GPU 採用一種叫「延遲渲染」的技術,會把渲染指令批次彙整,只在真正需要時才動手。因此,你該衡量的是整個渲染流程,而非中間的某個操作,因為它們的實際執行順序,很可能與你的想像不同。

不同裝置——桌面與行動——之間,最佳化的策略也大不相同,你或許得針對不同類型的裝置分別分析。舉例來說,行動 iOS 裝置上的 GPU 效能近年突飛猛進:iPhone 5S 的 CPU 比 iPhone 4 快了將近十倍,而 GPU 更是快上好幾百倍。

如果你在搭載 A7 晶片或更新機型的裝置上測試,得到的結果會與 iPhone 5 及更早的機型截然不同。Brad Larson 曾測試過高斯模糊在不同裝置上的耗時,非常直觀地展現了新機型上那份令人驚豔的效能躍升:

iPhone 機型 幀渲染時間(毫秒)

iPhone 4 873

iPhone 4S 145

iPhone 5 55

iPhone 5S 3

你可以下載 Imagination Technologies 的 PowerVR SDK,它能幫你分析著色器,並告訴你著色器渲染效能的最佳與最壞情況。若想維持高幀率,把渲染著色器所需的週期數壓到越低越好,至關重要。想達到每秒 60 幀,你只有 16.67 毫秒來完成全部處理。

這裡有幾個簡單可行的竅門,能幫你達成目標:

  • 消除條件邏輯: 有些時候條件邏輯無可避免,但盡量把它降到最低。善用 step() 這類函數的变通手法,能幫你避開一些昂貴的條件判斷。

  • 減少依賴紋理的讀取: 在片段著色器中取樣時,如果紋理座標不是直接以 varying 傳進來,而是在片段著色器裡現場計算,就會觸發「依賴紋理讀取」。這種讀取無法套用一般紋理讀取的快取最佳化,速度更慢。比如你想對鄰近像素取樣,與其每次在片段著色器中計算與相鄰像素的偏移,不如把計算挪到頂點著色器裡,再以 varying 傳入片段著色器。Brad Larson 文章中關於 Sobel 邊緣偵測的部分,就有這樣的範例。

  • 讓計算盡量簡單: 如果你能避開一個昂貴操作,換來一個精度足夠的近似值,那就這麼做。昂貴的運算包括呼叫三角函數,像 sin()、cos()、tan()。

  • 可能的話,把計算搬到頂點著色器: 前面談到的依賴紋理讀取,就是一個把紋理座標計算搬到頂點著色器的絕佳理由。如果某個計算在整張圖片上都得到相同結果,或呈線性變化,不妨想想能不能挪到頂點著色器裡做。頂點著色器每個頂點只跑一次,片段著色器卻要每個像素跑一次,放在前者的運算量自然小得多。

  • 在行動裝置上選對精度: 在某些行動裝置上,對向量使用低精度值會跑得更快。這些裝置上,兩個 lowp vec4 相加能在一個時鐘週期內完成,而兩個 highp vec4 相加卻要花四個週期。不過在桌面 GPU 與近年的行動 GPU 上,這差異已不再那麼明顯,因為它們對低精度值的最佳化方式不同。

結論與資源

著色器初看之下頗唬人,但它們說到底也不過是被改裝過的 C 程式而已。折騰著色器的那些事,我們大多數人在某些情境下其實都碰過,只是換了個語境罷了。

對於想深入鑽研著色器的人,我特別建議一件事:回頭複習三角學與線性代數。我在做相關工作時,遭遇的最大阻力,就是發現自己早已把大學學過的數學忘得差不多了,畢竟太久沒真正用過。

如果你的數學有點生疏,我推薦幾本書:

  • 3D Math Primer for Graphics and Game Development

  • The Nature of Code

  • The Computational Beauty of Nature

當然,市面上還有數不清的 GLSL 書籍,以及由業界翹楚親手打造的各類特殊著色器:

  • Graphics Shaders: Theory and Practice

  • The OpenGL Shading Language

  • OpenGL 4 Shading Language Cookbook

  • GPU Gems

  • GPU Pro: Advanced Rendering Techniques

還有,我必須再次強調:GPUImage 是個開源寶庫,裡頭有不少非常酷的著色器。學習著色器一個極好的方式,就是挑一個你覺得有意思的著色器,一行一行讀下去,遇到看不懂的地方就查。GPUImage 還附帶一個 Mac 端的著色器設計應用,讓你不必張羅 OpenGL 程式碼,就能直接測試著色器。

學會在程式碼中有效地實作著色器,能為你帶來可觀的效能提升。不仅如此,著色器還讓你能做出過去簡直不敢想的效果。

學著色器需要一點堅持與好奇心,但絕非不可能之事。如果連一個 33 歲、還在康復中的新聞專業出身的人,都能克服對數學的恐懼、把著色器拿下,那麼你肯定也行。


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