OpenGL ES 是 iOS 平台上用來做 2D 與 3D 繪圖的底層 API。你或許聽過 cocos2d、Sparrow、Corona、Unity 這些遊戲與動畫框架,但它們底下幾乎都靠 OpenGL 在運作。
多數開發者寧願用這些框架,也不直接碰 OpenGL,原因很單純:原生 OpenGL 的學習曲線實在陡得讓人卻步。這系列文章的目的,就是帶你用幾個小而實用的實驗,寫出一個「Hello World」等級的 OpenGL App——先畫出簡單的平面圖形,再一步步把它變成會轉動的立體方塊。
整個流程大致是:
·建立一個最精簡的 OpenGL App
·編譯並執行 vertex 與 fragment 著色器
·透過 vertex buffer 在螢幕上畫出一個矩形
·套用 projection 與 model-view 矩陣
·加上 depth testing,渲染真正的 3D 物件
先說清楚:我不是 OpenGL 專家,以下內容來自自學與實作,若有任何錯誤歡迎指正。
入門前你必須先搞懂這兩個版本的差異,而差異不是「有點不同」,是「根本是兩回事」。
OpenGL ES 1.0走的是固定管線(fixed pipeline)。光源、頂點、顏色、視角等設定,都由內建函式直接指定,寫起來直覺,但自由度受限。
OpenGL ES 2.0則是可程式化管線(programmable pipeline)。內建函式幾乎被拿掉了,取而代之的是——你得自己動手把每個功能寫出來。
聽到這裡你可能會想:那我幹嘛還要用 2.0?因為 2.0 能做到 1.0 做不到的事,例如 toon shading(卡通渲染)這類效果。

靠著自訂著色器,你甚至能做出相當有質感的光影與材質:

需要留意的是硬體門檻:OpenGL ES 2.0 需要 iPhone 3GS 以上、iPod Touch 3G 以上,以及所有版本的 iPad。以現在的裝置分布來說,這基本不是問題。
Xcode 雖然自帶 OpenGL ES 的專案範本,但那個範本一次產生大量程式碼,對初學者反而是一種負擔。所以我們從零開始手刻,每一步都自己寫,這樣你才真的看得懂它在做什麼。
開啟 Xcode 建立新專案,命名為 HelloOpenGL,選擇存放位置後按「建立」。接下來的程式碼都寫在 OpenGLView 相關檔案裡。
在 Groups & Files 中找到 target「HelloOpenGL」,展開「Link Binary with Libraries」,點「+」加入以下兩個框架:
·OpenGLES.framework
·QuartzCore.framework
引入所需的 header,並宣告稍後會用到的實例變數:
#import <UIKit/UIKit.h>
#import <QuartzCore/QuartzCore.h>
#include <OpenGLES/ES2/gl.h>
#include <OpenGLES/ES2/glext.h>
@interface OpenGLView : UIView {
CAEAGLLayer *_eaglLayer;
EAGLContext *_context;
GLuint _colorRenderBuffer;
}
@end
要顯示 OpenGL 的內容,預設的 layer 必須換成專用的 CAEAGLLayer,做法是覆寫 layerClass:
+ (Class)layerClass {
return [CAEAGLLayer class];
}
- (void)setupLayer {
_eaglLayer = (CAEAGLLayer *)self.layer;
_eaglLayer.opaque = YES;
}
CALayer 預設是透明的,而透明圖層的合成成本很高,對 OpenGL 圖層尤其明顯。能設成不透明就盡量設,這條規則在自訂 tableview cell 上同樣適用。
- (void)setupContext {
EAGLRenderingAPI api = kEAGLRenderingAPIOpenGLES2;
_context = [[EAGLContext alloc] initWithAPI:api];
if (!_context) {
NSLog(@"Failed to initialize OpenGLES 2.0 context");
exit(1);
}
if (![EAGLContext setCurrentContext:_context]) {
NSLog(@"Failed to set current OpenGL context");
exit(1);
}
}
EAGLContext 管理所有透過 OpenGL 進行的繪製資訊,角色有點像 Core Graphics 的 context。建立時你必須宣告要用哪個版本的 API,這裡選的是 OpenGL ES 2.0;若建立失敗,程式直接結束。
- (void)setupRenderBuffer {
glGenRenderbuffers(1, &_colorRenderBuffer);
glBindRenderbuffer(GL_RENDERBUFFER, _colorRenderBuffer);
[_context renderbufferStorage:GL_RENDERBUFFER fromDrawable:_eaglLayer];
}
render buffer 用來存放渲染後的影像,因為其中存的就是要顯示的顏色,所以也常被叫作 color buffer。建立流程固定三步:
1. glGenRenderbuffers 建立一個新的 render buffer 物件,回傳一個唯一 ID(這裡存入 _colorRenderBuffer)。這個 ID 就是你在程式裡指稱該 OpenGL 物件的名字。
2. glBindRenderbuffer 告訴 OpenGL:後續提到 GL_RENDERBUFFER 時,指的就是這個物件。
3. renderbufferStorage 為它配置實際的儲存空間。
- (void)setupFrameBuffer {
GLuint framebuffer;
glGenFramebuffers(1, &framebuffer);
glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
GL_RENDERBUFFER, _colorRenderBuffer);
}
frame buffer 同樣是 OpenGL 物件,它「裝著」前面那個 render buffer,未來還可以掛上 depth buffer、stencil buffer、accumulation buffer 等。前兩步和建立 render buffer幾乎一樣,關鍵在最後一行 glFramebufferRenderbuffer:它把 color render buffer 掛到 frame buffer 的 GL_COLOR_ATTACHMENT0 位置。
- (void)render {
glClearColor(0, 104.0 / 255.0, 55.0 / 255.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT);
[_context presentRenderbuffer:GL_RENDERBUFFER];
}
在跟頂點、著色器纏鬥之前,先讓螢幕出現一塊綠色,確認管線是通的。注意這裡每個 RGB 分量的範圍是 0~1,所以要把 0~255 的值除以 255。
三個動作的意義:glClearColor 設定填充色與透明度;glClear 執行填色(就像影像軟體的油漆桶),並用 GL_COLOR_BUFFER_BIT 指定要清哪個 buffer;presentRenderbuffer 把結果實際呈現到 UIView 上。
- (id)initWithFrame:(CGRect)frame {
self = [super initWithFrame:frame];
if (self) {
[self setupLayer];
[self setupContext];
[self setupRenderBuffer];
[self setupFrameBuffer];
[self render];
}
return self;
}
- (void)dealloc {
[_context release];
_context = nil;
[super dealloc];
}
在 HelloOpenGLAppDelegate.h 中:
#import "OpenGLView.h"
@interface HelloOpenGLAppDelegate : NSObject <UIApplicationDelegate> {
OpenGLView *_glView;
}
@property (nonatomic, retain) IBOutlet OpenGLView *glView;
@end
接著在 .m 中:
@synthesize glView = _glView;
// application:didFinishLaunchingWithOptions: 開頭
CGRect screenBounds = [[UIScreen mainScreen] bounds];
self.glView = [[[OpenGLView alloc] initWithFrame:screenBounds] autorelease];
[self.window addSubview:_glView];
// dealloc 中
[_glView release];
一切順利的話,執行後你會看到一整片綠——歡迎來到 OpenGL 的世界。

在 OpenGL ES 2.0 裡,想畫出任何幾何圖形,你都得先準備兩個小程式,合稱「著色器」(shader),用一種類 C 的 GLSL 語言撰寫。這裡先知道有這件事即可,暫不深入語法。
·Vertex shader:場景中每個頂點都會呼叫一次。若你要畫一個矩形,四個角就是四個頂點,於是它被呼叫四次。它負責光源計算、座標變換等工作,算出最終頂點位置後,把結果交給 fragment shader。
·Fragment shader:大致上每個像素都會呼叫一次。同一個矩形覆蓋到的每個像素,都要跑一次 fragment shader,最終決定這個像素的顏色。
建立 SimpleVertex.glsl(File → New → New File → iOS → Other → Empty):
attribute vec4 Position; // 1
attribute vec4 SourceColor; // 2
varying vec4 DestinationColor; // 3
void main(void) { // 4
DestinationColor = SourceColor; // 5
gl_Position = Position; // 6
}
逐行解讀:
1. attribute 表示這是一個傳入變數,稍後你會用它把頂點位置餵進來。型別 vec4 代表四元件向量。
2. 同理,這是傳入的顏色。
3. 沒有 attribute 關鍵字,表示它是傳出變數,會往 fragment shader 傳。varying 的意義是:依頂點顏色在兩頂點之間做平滑插值,算出中間每個像素的顏色。
4. 每個 shader 都從 main 開始,跟 C 一樣。
5. 把輸出顏色設為輸入顏色。
6. gl_Position 是 vertex shader 必寫的內建輸出變數,這裡不做任何運算,直接對號入座。
關於 varying 的插值,一張圖勝千言:

圖中某個像素落在紅色頂點與綠色頂點之間,換算後它距離上方頂點 55/100、距離下方頂點 45/100,於是顏色就按比例過渡出來。
接著建立 SimpleFragment.glsl:
varying lowp vec4 DestinationColor; // 1
void main(void) { // 2
gl_FragColor = DestinationColor; // 3
}
1. 與 vertex shader 中同名同型別的 varying 變數對應。額外多了 lowp 這個精度修飾字:fragment shader 必須標明計算精度,在效能考量下預設用最低精度是好習慣,需要時再換成 mediump 或 highp。
2. 一樣從 main 進入。
3. 正如 vertex shader 必須寫 gl_Position,fragment shader 必須寫 gl_FragColor。這裡先原封不動地沿用頂點傳來的值。
目前 Xcode 只會把這兩個 .glsl 檔複製進 App bundle,真正的編譯要留到執行期才做。
你可能會疑惑:為什麼不預先編譯好?因為執行期編譯的著色器不綁定特定 GPU 指令集,這正是跨平台的關鍵。
在 OpenGLView.m 的 initWithFrame: 之前加入:
- (GLuint)compileShader:(NSString *)shaderName withType:(GLenum)shaderType {
// 1. 從 bundle 讀出原始碼
NSString *shaderPath = [[NSBundle mainBundle] pathForResource:shaderName ofType:@"glsl"];
NSError *error;
NSString *shaderString = [NSString stringWithContentsOfFile:shaderPath
encoding:NSUTF8StringEncoding
error:&error];
if (!shaderString) {
NSLog(@"Error loading shader: %@", error.localizedDescription);
exit(1);
}
// 2. 建立 shader 物件
GLuint shaderHandle = glCreateShader(shaderType);
// 3. 塞入原始碼
const char *shaderStringUTF8 = [shaderString UTF8String];
int shaderStringLength = [shaderString length];
glShaderSource(shaderHandle, 1, &shaderStringUTF8, &shaderStringLength);
// 4. 編譯
glCompileShader(shaderHandle);
// 5. 檢查錯誤
GLint compileSuccess;
glGetShaderiv(shaderHandle, GL_COMPILE_STATUS, &compileSuccess);
if (compileSuccess == GL_FALSE) {
GLchar messages[256];
glGetShaderInfoLog(shaderHandle, sizeof(messages), 0, &messages[0]);
NSString *messageString = [NSString stringWithUTF8String:messages];
NSLog(@"%@", messageString);
exit(1);
}
return shaderHandle;
}
重點:NSBundle 取檔是 UIKit 的標準寫法;glCreateShader 建立 shader 物件時必須指明型別;glShaderSource 把原始碼交給 OpenGL(記得把 NSString 轉成 C 字串);glCompileShader 進行編譯;最後用 glGetShaderiv 與 glGetShaderInfoLog 把錯誤訊息印出來——有程式就會有 bug,除錯是常態。
接著把兩支 shader 組裝成一個 program:
- (void)compileShaders {
// 1. 分別編譯
GLuint vertexShader = [self compileShader:@"SimpleVertex" withType:GL_VERTEX_SHADER];
GLuint fragmentShader = [self compileShader:@"SimpleFragment" withType:GL_FRAGMENT_SHADER];
// 2. 附加並連結
GLuint programHandle = glCreateProgram();
glAttachShader(programHandle, vertexShader);
glAttachShader(programHandle, fragmentShader);
glLinkProgram(programHandle);
// 3. 檢查連結結果
GLint linkSuccess;
glGetProgramiv(programHandle, GL_LINK_STATUS, &linkSuccess);
if (linkSuccess == GL_FALSE) {
GLchar messages[256];
glGetProgramInfoLog(programHandle, sizeof(messages), 0, &messages[0]);
NSString *messageString = [NSString stringWithUTF8String:messages];
NSLog(@"%@", messageString);
exit(1);
}
// 4. 啟用
glUseProgram(programHandle);
// 5. 取得 attribute 位置並啟用
_positionSlot = glGetAttribLocation(programHandle, "Position");
_colorSlot = glGetAttribLocation(programHandle, "SourceColor");
glEnableVertexAttribArray(_positionSlot);
glEnableVertexAttribArray(_colorSlot);
}
glCreateProgram、glAttachShader、glLinkProgram 三個一組,把兩支 shader 組成完整程式;glGetProgramiv / glGetProgramInfoLog 負責檢查連結錯誤;glUseProgram 讓 OpenGL 真正採用它;glGetAttribLocation 取得傳入變數的「位置代號」,之後就靠這些代號餵資料(attribute array 預設是關閉的,所以要呼叫 glEnableVertexAttribArray)。
最後兩小步:在 initWithFrame: 中、呼叫 render 之前插入 [self compileShaders];;並在 OpenGLView.h 的 @interface 中補上兩個變數:
GLuint _positionSlot;
GLuint _colorSlot;
編譯執行。如果綠色畫面還在,代表前面的程式都沒問題。
接下來要在螢幕中央畫一個正方形:

這裡有個 OpenGL 鐵律:能直接渲染的圖元只有三角形。所以正方形必須拆成兩個三角形,圖中是(0,1,2)與(0,2,3)。
OpenGL ES 2.0 的彈性在於,頂點資料怎麼組織由你決定。我們定義一個純 C 結構來描述每個頂點:
typedef struct {
float Position[3];
float Color[4];
} Vertex;
const Vertex Vertices[] = {
{{ 1, -1, 0}, {1, 0, 0, 1}},
{{ 1, 1, 0}, {0, 1, 0, 1}},
{{-1, 1, 0}, {0, 0, 1, 1}},
{{-1, -1, 0}, {0, 0, 0, 1}}
};
const GLubyte Indices[] = {
0, 1, 2,
2, 3, 0
};
Vertex 結構目前只包含位置與顏色;Vertices 是這結構的陣列;Indices 則用索引描述三角形由哪些頂點組成。
要把資料交給 OpenGL,最合適的方式是 Vertex Buffer Object(VBO)。你可以把它想成用來暫存頂點資料的 OpenGL 物件。這裡有兩種:一種存頂點屬性(對應 Vertices),一種存三角形索引(對應 Indices)。
在 initWithFrame: 中加入 [self setupVBOs];,並實作:
- (void)setupVBOs {
GLuint vertexBuffer;
glGenBuffers(1, &vertexBuffer);
glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
glBufferData(GL_ARRAY_BUFFER, sizeof(Vertices), Vertices, GL_STATIC_DRAW);
GLuint indexBuffer;
glGenBuffers(1, &indexBuffer);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(Indices), Indices, GL_STATIC_DRAW);
}
glGenBuffers 建立物件、glBindBuffer 綁定型別、glBufferData 上傳資料——這組三步驟的模式,和前面建立 frame buffer 時如出一轍。
萬事俱備,把 render 換成下面的版本:
- (void)render {
glClearColor(0, 104.0 / 255.0, 55.0 / 255.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT);
// 1. 設定視埠
glViewport(0, 0, self.frame.size.width, self.frame.size.height);
// 2. 設定 attribute 的讀取方式
glVertexAttribPointer(_positionSlot, 3, GL_FLOAT, GL_FALSE,
sizeof(Vertex), 0);
glVertexAttribPointer(_colorSlot, 4, GL_FLOAT, GL_FALSE,
sizeof(Vertex), (GLvoid *)(sizeof(float) * 3));
// 3. 畫出來
glDrawElements(GL_TRIANGLES, sizeof(Indices) / sizeof(Indices[0]),
GL_UNSIGNED_BYTE, 0);
[_context presentRenderbuffer:GL_RENDERBUFFER];
}
glViewport 決定渲染區域,這裡用整個 view,你也可以只畫其中一小塊。
glVertexAttribPointer 是個值得細看的函式,六個參數分別是:
·屬性的位置代號(就是前面 glGetAttribLocation 拿到的值)
·這屬性由幾個分量組成(位置 3 個 float,顏色 4 個 float)
·每個分量的型別(這裡都是 GL_FLOAT)
·是否正規化,通常填 GL_FALSE
·stride,也就是「一個頂點佔多少位元組」,直接給 sizeof(Vertex) 讓編譯器算
·位移量。位置在最前面所以填 0;顏色緊接在 3 個 float 之後,所以是 sizeof(float) * 3
glDrawElements 則是真正觸發繪製的呼叫,它會為每個頂點跑 vertex shader、為每個像素跑 fragment shader。四個參數:
·圖元型態,GL_LINE_STRIP、GL_TRIANGLE_FAN、GL_TRIANGLES 等,搭配 VBO 時 GL_TRIANGLES 最常用
·要畫的數量,這裡用索引陣列的位元組大小除以單一索引大小算出
·索引的型別
·索引指標。因為資料已經放在 GL_ELEMENT_ARRAY_BUFFER 裡,這裡給 NULL(0)即可
執行後你會看到一個填滿畫面的彩色正方形:

為什麼剛好占滿整個螢幕?因為預設情況下,OpenGL 的「camera」位於 (0,0,0),朝 z 軸正方向看。接下來我們就來處理投影與視角。
要在 2D 螢幕上呈現 3D 場景,必須做投影變換:

概念是模仿人眼:設定一個近平面與遠平面,靠近近平面的物件看起來變小,靠近遠平面的則變大,於是產生景深。
修改 SimpleVertex.glsl:
// 加在 main 之前
uniform mat4 Projection;
// 修改 gl_Position 那一行
gl_Position = Projection * Position;
uniform 代表這是一個對所有頂點都相同的常數,不會因頂點而異;mat4 是 4×4 矩陣。矩陣運算本身是大主題,這裡先把它當成「負責縮放、旋轉、變形」的工具。位置乘以投影矩陣,就得到最終的裁剪空間座標。
這套數學稱為線性代數,好消息是有人已經幫我們寫好了。cocos3d 作者 Bill Hollings 做了一套完整的 3D 支援並整合進 cocos2d,其中包含 Objective-C 的向量與矩陣函式庫,我們可以直接拿來用。
下載 Cocos3DMathLib.zip(https://d1xzuxjlafny7l.cloudfront.net/downloads/Cocos3DMathLib.zip),解壓後拖進專案,記得勾選「Copy items into destination group's folder (if needed)」。
在 OpenGLView.h 加上:
GLuint _projectionUniform;
在 OpenGLView.m 中:
// 檔案頂端
#import "CC3GLMatrix.h"
// compileShaders 尾端
_projectionUniform = glGetUniformLocation(programHandle, "Projection");
// render 中,glViewport 呼叫之前
CC3GLMatrix *projection = [CC3GLMatrix matrix];
float h = 4.0f * self.frame.size.height / self.frame.size.width;
[projection populateFromFrustumLeft:-2 andRight:2
andBottom:-h/2 andTop:h/2
andNear:4 andFar:10];
glUniformMatrix4fv(_projectionUniform, 1, 0, projection.glMatrix);
// 把頂點挪進近遠平面之間
const Vertex Vertices[] = {
{{ 1, -1, -7}, {1, 0, 0, 1}},
{{ 1, 1, -7}, {0, 1, 0, 1}},
{{-1, 1, -7}, {0, 0, 1, 1}},
{{-1, -1, -7}, {0, 0, 0, 1}}
};
流程是:用 glGetUniformLocation 取得 Projection 的位置;用矩陣函式庫依視錐參數建立投影矩陣;用 glUniformMatrix4fv 把矩陣傳進 shader(CC3GLMatrix 的 glMatrix 屬性已經幫你轉成 OpenGL 要的陣列格式);最後把頂點 z 座標改為 -7,讓它落在近遠平面之間。
執行後,正方形會離你遠一些:

每次想改圖形都要去改頂點陣列,這做法太笨重了。正確答案是用變換矩陣。
我們再來一個 uniform 矩陣,專門負責平移、縮放、旋轉,這就是 model-view 矩陣。回到 SimpleVertex.glsl:
// 加在 Projection 之後
uniform mat4 Modelview;
// 修改 gl_Position
gl_Position = Projection * Modelview * Position;
OpenGLView.h 加上:
GLuint _modelViewUniform;
OpenGLView.m 中:
// compileShaders 尾端
_modelViewUniform = glGetUniformLocation(programHandle, "Modelview");
// render 中,glViewport 之前
CC3GLMatrix *modelView = [CC3GLMatrix matrix];
[modelView populateFromTranslation:CC3VectorMake(sin(CACurrentMediaTime()), 0, -7)];
glUniformMatrix4fv(_modelViewUniform, 1, 0, modelView.glMatrix);
// 頂點 z 座標改回 0
const Vertex Vertices[] = {
{{ 1, -1, 0}, {1, 0, 0, 1}},
{{ 1, 1, 0}, {0, 1, 0, 1}},
{{-1, 1, 0}, {0, 0, 1, 1}},
{{-1, -1, 0}, {0, 0, 0, 1}}
};
平移量在 z 軸 -7,而 x 軸用了 sin(當前時間)。還記得三角函數嗎?sin 的值在 -1 到 1 之間擺盪,週期是 π(約 3.14),所以這個方塊會大約每 3 秒左右做一次前後往返。
執行後你會看到正方形回到畫面中央——而且完全靜止。當然,因為 render 只被呼叫了一次。

理想狀態是讓繪製頻率跟螢幕刷新頻率同步。Apple 提供了 CADisplayLink 這個方便的類別,直接用就對了。
// 加在 init 之前
- (void)setupDisplayLink {
CADisplayLink *displayLink = [CADisplayLink displayLinkWithTarget:self
selector:@selector(render:)];
[displayLink addToRunLoop:[NSRunLoop currentRunLoop]
forMode:NSDefaultRunLoopMode];
}
// render 改成帶參數的版本
- (void)render:(CADisplayLink *)displayLink {
...
}
// initWithFrame 中,把原本的 [self render] 換成
[self setupDisplayLink];
現在每一幀都會呼叫一次 render,方塊終於會隨 sin 曲線前後移動了。

會動的圖形才算有型。在 OpenGLView.h 補一個成員變數:
float _currentRotation;
並在 render 中、populateFromTranslation 之後加上:
_currentRotation += displayLink.duration * 90;
[modelView rotateBy:CC3VectorMake(_currentRotation, _currentRotation, 0)];
_currentRotation 每秒遞增 90 度;接著對 model-view 矩陣套用旋轉,作用軸是 x 與 y,z 軸不動。
執行後,你會得到一個翻轉中的 3D 效果。

目前為止只能算 2.5D——它是一個會旋轉的平面。把頂點與索引換成六個面的版本:
const Vertex Vertices[] = {
{{ 1, -1, 0}, {1, 0, 0, 1}},
{{ 1, 1, 0}, {1, 0, 0, 1}},
{{-1, 1, 0}, {0, 1, 0, 1}},
{{-1, -1, 0}, {0, 1, 0, 1}},
{{ 1, -1, -1}, {1, 0, 0, 1}},
{{ 1, 1, -1}, {1, 0, 0, 1}},
{{-1, 1, -1}, {0, 1, 0, 1}},
{{-1, -1, -1}, {0, 1, 0, 1}}
};
const GLubyte Indices[] = {
// Front
0, 1, 2,
2, 3, 0,
// Back
4, 6, 5,
4, 7, 6,
// Left
2, 7, 3,
7, 6, 2,
// Right
0, 4, 1,
4, 1, 5,
// Top
6, 2, 1,
1, 6, 5,
// Bottom
0, 3, 7,
0, 7, 4
};
執行後你會看到一個方塊,但看起來有點假——因為你能透視到方塊內部。這時候需要 depth testing(深度測試):啟用之後,OpenGL 會追蹤每個像素在 z 軸上的深度,只有當它前面沒有其他東西時才繪製。
OpenGLView.h 補上:
GLuint _depthRenderBuffer;
OpenGLView.m 中:
// 加在 setupRenderBuffer 之後
- (void)setupDepthBuffer {
glGenRenderbuffers(1, &_depthRenderBuffer);
glBindRenderbuffer(GL_RENDERBUFFER, _depthRenderBuffer);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16,
self.frame.size.width, self.frame.size.height);
}
// setupFrameBuffer 尾端
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
GL_RENDERBUFFER, _depthRenderBuffer);
// render 中,取代原本的 glClear
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
// initWithFrame 中,setupRenderBuffer 之前
[self setupDepthBuffer];
setupDepthBuffer 的寫法和 color buffer 幾乎相同,差別在於這裡用 glRenderbufferStorage 搭配 GL_DEPTH_COMPONENT16,而不是 context 的 renderbufferStorage:fromDrawable:(後者是專為 color render buffer 設計的)。接著用 glFramebufferRenderbuffer 把深度 buffer 掛到 GL_DEPTH_ATTACHMENT——這正好印證了前面所說的「frame buffer 裡可以裝多種 buffer」。最後在每幀清除深度 buffer 並開啟深度測試。
執行到這裡,教程的最終成果就完成了:一個會旋轉、具備正確遮蔽關係的 3D 方塊,全部跑在 OpenGL ES 2.0 上。

回頭看,OpenGL ES 2.0 的每一個環節其實都不複雜,只是步驟多、概念彼此扣合。搞懂了 context、buffer、著色器與矩陣這四塊拼圖,再往上的材質、光照、模型載入就有了施力點。