帧缓冲：画面画好了存到哪里

CH-09-01-009·约 22 分钟·计算机图形学与可视化·更新 2026-08-11

你有没有想过，我们在屏幕上看到的每一帧画面，其实是显卡“画”出来的？但这个“画”的过程并不是直接往屏幕上涂颜色——就像一位画家创作时，不会直接在大街上画画，而是先在画室里，面对一块画布，精心调配颜色、反复修改，等作品完成之后才装裱展出。在计算机图形学里，这块“画布”就是帧缓冲（Framebuffer），而那块可以反复使用的“画布”叫渲染目标（Render Target）。当你玩游戏、看 3D 动画、给照片加滤镜时，背后都有一块看不见的“画布”在默默承接着每一次落笔、每一笔修改。这篇文章，我们就一起走进这块画布背后的故事，看看画面画好了，到底存到了哪里。

岗位关联

搞懂帧缓冲和渲染目标，你就能真正理解 GPU 里“画完存哪、怎么取用”的核心机制，这在游戏开发、图像后处理、离屏渲染乃至引擎架构设计中，都是绕不开的底层功底。

可视化演示
画家与画布
帧缓冲结构
附件与绑定
离屏渲染
多目标渲染
全流程落地
AI 应用场景
Python 演示
常见误区
面试题

可视化演示

展示帧缓冲FBO的结构、创建流程与多目标渲染MRT原理。

本节配有交互动效（进入视口后自动加载，约 3KB）。

帧缓冲三大附件结构颜色附件：存储RGBA像素颜色值深度附件：存储片元到摄像机距离 FBO = Color + Depth + Stencil GPU内存区域存储渲染结果

画家与画布

想象一位画家的工作室：墙上挂着许多已经完成的作品，但画家本人并不直接在这些成品上作画。他面前有一块独立的画布，这块画布里可以放很多层“纸”——一层用来涂颜色，一层用来记录前后遮挡关系，还有一层用来画辅助轮廓。只有在整幅画彻底完成之后，他才会把画布上的内容“转印”到展厅的墙上供人欣赏。

在 GPU 的世界里，这个“展厅的墙”就是你的显示器，而那块画布就是帧缓冲（Framebuffer）。过去 GPU 绘制的每一帧，都不是直接写到屏幕上的，而是先画到一个称之为帧缓冲的中间存储结构里。这个结构本身不直接保存画面数据，它更像一个“收纳盒”——盒子里装着多张不同类型的“纸”，这些纸才真正存储像素数据。

这些“纸”在图形学里统称为附件（Attachment），其中最核心的是颜色、深度和模板三类。而渲染目标（Render Target）则是从用途视角对帧缓冲的另一种称呼——凡是能被 GPU 当作“画布”去绘制的东西，都可以叫渲染目标。它可能是屏幕本身（默认帧缓冲），也可能是一张纹理（离屏渲染目标）。

回到画家的比喻：帧缓冲是画布这个“整体”，附件是画布上别上去的三张纸。画布本身不决定画什么，它只是个容器——真正承载颜料的，是那三张纸。

\text{Framebuffer} = \{\,\text{Color Attachment},\ \text{Depth Attachment},\ \text{Stencil Attachment}\,\}

帧缓冲是一个“盒子”，盒子里装着三种纸：颜色纸记录画面颜色，深度纸记录远近遮挡，模板纸记录区域裁剪。

帧缓冲集合定义帧缓冲不是一块单独的内存，而是三类附件的集合容器。
$\text{Framebuffer} = \{\,\text{Color Attachment},\ \text{Depth Attachment},\ \text{Stencil Attachment}\,\}$
颜色附件存储每个像素的 RGBA 颜色值，是最终展示给人眼的部分。
$\text{Color Attachment}:\ (R, G, B, A) \in [0,1]^4$
深度附件存储每个像素的深度值，用于判断哪个物体更靠近相机。
$\text{Depth Attachment}:\ z \in [0,1]$

帧缓冲结构

画家在创作一幅风景画时，第一张纸涂满天空和山水的颜色，这是整幅画的基础；第二张纸记录“哪个物体在前、哪个物体在后”，比如远处的山肯定在近处的树后面；第三张纸是一张镂空模板，只有当笔尖落在模板的镂空区域内时，颜料才会真正涂下去——比如用喷漆往墙上喷字，你得先把刻好字的纸板挡在墙前，喷漆只能透过镂空的部分落上去。

这三张纸，分别对应帧缓冲里的三大类附件。第一张颜色附件（Color Attachment），存储每个像素的 RGBA 值，它决定了最终画面长什么样。我们可以同时挂多张颜色附件到同一个帧缓冲上，分别命名为 GL_COLOR_ATTACHMENT0、GL_COLOR_ATTACHMENT1……这正是后面多目标渲染（MRT）的基础。

第二张深度附件（Depth Attachment），存储每个片元的深度值，通常是一个 16 位或 24 位的浮点数。GPU 每画一个片元，都会先比较这个片元的深度与深度附件里已有值的远近：更近就覆盖，更远就丢弃。这个过程称作深度测试（Depth Test），它保证了物体之间的遮挡关系始终正确。

第三张模板附件（Stencil Attachment），存储模板值（常用 8 位整数）。GPU 可以设置模板测试规则，比如“只有模板值等于 1 的地方才允许绘制”。这在实现镜子、剪影、轮廓描边、阴影体积等效果时非常有用——就像用纸板镂空喷漆，模板决定了哪些区域能被“喷上”颜色。

回到画家的三张纸：颜色纸负责“画了什么”，深度纸负责“谁挡谁”，模板纸负责“哪里能画”。三者互相配合，才能产出一幅正确、完整的画面。

z_{\text{new}} < z_{\text{old}} \Rightarrow \text{discard old}; \quad z_{\text{new}} \ge z_{\text{old}} \Rightarrow \text{discard new}

深度测试的规则：新的片元比旧的更近，才会覆盖旧片元，否则就丢弃新片元——保证近处的物体挡住远处的。

深度比较操作把新片元的深度与深度附件中存储的旧深度进行比较，决定谁保留。
$z_{\text{new}} \quad \text{vs} \quad z_{\text{old}}$
覆盖条件新片元深度更小时，说明它更靠近相机，用它的颜色覆盖旧片元。
$z_{\text{new}} < z_{\text{old}} \Rightarrow \text{write}$
丢弃条件新片元深度更大时，说明它被旧片元挡住，直接丢弃。
$z_{\text{new}} \ge z_{\text{old}} \Rightarrow \text{discard}$

附件与绑定

画家在前面的故事里用了三张纸：颜色纸、深度纸、模板纸。但这里有个细节——这三张纸不是画布自带的，而是画家从抽屉挑出来，一张张“别”到画布上去的。不同场景需要不同的纸：画素描只要一张纸；画水彩需要吸水纸；画立体油画则要厚实的亚麻布。画布本身只是一个框架，真正干活的是被“绑定”到框架上的纸。

在 OpenGL 中，附件有两种来源。第一种是纹理（Texture）——它本身就是一张很有用的“纸”，因为纹理可以在后续的绘制中被 GPU 采样读取。把纹理挂到帧缓冲的颜色附件上，你就实现了一次“离屏渲染到纹理”，画面产生的每一个像素都存进了纹理里，之后你可以在其他着色器里像读取普通贴图一样读取它，这就是后处理、阴影贴图、环境反射等技术的基石。

第二种是渲染缓冲对象（Renderbuffer）——它是一张“普通白纸”，只能作为附件供 GPU 写入，无法被采样。它的好处是存储布局针对渲染进行了深度优化，读写速度在某些场景下比纹理更快，尤其适合做深度附件的容器。渲染缓冲对象的 API 使用 glGenRenderbuffers / glRenderbufferStorage 创建并分配存储，这个流程和纹理的 glGenTextures / glTexImage2D 流程高度对称。

绑定附件之后，还必须检查帧缓冲完整性（Framebuffer Completeness）：如果颜色纸和深度纸尺寸不一致，或者缺了某些必要附件，GPU 就会拒绝在这块画布上作画，此时你应当调用 glCheckFramebufferStatus 来诊断错误码，对症下药。

这一节的关键在于“挑纸”的智慧：纹理是一张可以反复查看和复用的高级纸，渲染缓冲是一次性的草稿纸。你能根据用途灵活选择，才真正掌握了画布的使用之道。

\text{FBO} \xleftrightarrow{\text{glFramebufferTexture2D}} \text{Texture}; \quad\text{FBO} \xleftrightarrow{\text{glFramebufferRenderbuffer}} \text{Renderbuffer}

附件绑定的本质是将帧缓冲的挂载点与具体的纹理或渲染缓冲对象建立连接——纹理适合“画完还要再用”，渲染缓冲适合“画完就不管了”。

纹理绑定调用 glFramebufferTexture2D 把一张纹理挂到 FBO 的某个颜色挂载点上。
$\text{FBO} \xleftrightarrow{\text{glFramebufferTexture2D}} \text{Texture}$
渲染缓冲绑定调用 glFramebufferRenderbuffer 把渲染缓冲对象挂到 FBO 的深度或模板挂载点上。
$\text{FBO} \xleftrightarrow{\text{glFramebufferRenderbuffer}} \text{Renderbuffer}$
完整性检查在开始绘制前用 glCheckFramebufferStatus 验证所有附件格式匹配、尺寸一致。
$\text{status} = \text{glCheckFramebufferStatus}(\text{GL\_FRAMEBUFFER})$

离屏渲染

有了画布和纸，画家发现了一个新玩法：他可以在工作室的角落里再支起一块不用于展出的画布，先在幕后画一些素材——比如画一幅雾气效果图，或者画一张光的反射图——然后再把这张“幕后作品”当作素材贴到主画面上。这样主画面的绘制过程就变得非常灵活，甚至可以反复调整灯光效果而不必重画整个场景。

这个“幕后画布”的技术，就是离屏渲染（Off-Screen Rendering）。在 OpenGL 中，我们要做三件事：第一步，调用 glGenFramebuffers 创建一个 FBO 对象；第二步，调用 glBindFramebuffer(GL_FRAMEBUFFER, fbo) 把它设为当前绘制目标；第三步，将一张纹理（或渲染缓冲对象）作为颜色附件绑定上去。之后所有绘制指令都会写入这张纹理，而不是默认的屏幕帧缓冲。

离屏渲染最常见的应用是后处理（Post-Processing）：先渲染整幅场景到一张纹理上，然后把这个纹理作为一个输入传给全屏像素着色器，对每个像素做模糊、色调映射、泛光、边缘检测、色彩分级等操作，最后才把结果写到屏幕上。整个过程就像拍完照片后用 Photoshop 调整——先拍到一张底片，再在电脑上做后期，而不是在拍照时强行改变真实世界的颜色。

在工程上，离屏渲染还需要注意视口大小要与附件尺寸一致。调用 glViewport(0, 0, width, height) 时，宽高应当与纹理的尺寸匹配，否则画面会被拉伸或裁剪。此外，渲染完成后如果你想脱离 FBO、重新绘制到屏幕，需要调用 glBindFramebuffer(GL_FRAMEBUFFER, 0) 恢复默认帧缓冲——这相当于画家把注意力从幕后画布移回展厅主画布。

画家在幕后画布上画的“雾气图”，最终被贴回主画面，让整幅作品有了朦胧的氛围感——这正是后处理离屏渲染的经典写照：先在幕后做效果，再拼回主线画面。

\text{Off-Screen}: \quad \text{Scene} \xrightarrow{\text{draw}} \text{FBO}(\text{texture}) \xrightarrow{\text{read}} \text{Shader} \xrightarrow{\text{draw}} \text{Default Framebuffer}

离屏渲染解决的问题是“从哪画”：默认可画到屏幕，也可以画到纹理。画到纹理之后，这份“幕后素材”可以被任意后处理效果反复使用。

场景绘制到纹理把完整场景的所有绘制指令执行到绑定的 FBO 颜色附件上。
$\text{Scene} \xrightarrow{\text{draw}} \text{FBO}(\text{texture})$
纹理读取后处理着色器以该纹理作为输入采样。
$\text{FBO}(\text{texture}) \xrightarrow{\text{read}} \text{Shader}$
结果写回屏幕处理后的颜色输出到默认帧缓冲，最终被显示器呈现。
$\text{Shader} \xrightarrow{\text{draw}} \text{Default Framebuffer}$

多目标渲染

画面越来越复杂，画家发现每次画完颜色还要单独画深度和法线，来回换纸太慢了。他灵机一动：为什么不能在画布上同时别三张不同的颜色纸，一次性把所有需要的信息都画下来？比如第一张纸画最终颜色，第二张纸画每个物体的法线方向，第三张纸画材质粗糙度。这样后续做光照计算时，三张纸可以直接拼合成完整的材质信息，不必重新渲染一遍场景。

这个技术在 OpenGL 中叫做多目标渲染（Multiple Render Targets，MRT）。它的核心机制是：在片元着色器中，你可以声明一个输出数组或为每个输出指定 layout(location = n) out vec4，GPU 会将这些输出分别写入当前绑定 FBO 的不同颜色附件。由于 FBO 本身支持多个颜色附件（GL_COLOR_ATTACHMENT0 到 GL_COLOR_ATTACHMENTn），一次完整的光栅化就能同时产生 n 张输出纹理。

MRT 最经典的应用场景是延迟渲染（Deferred Rendering）。在延迟渲染中，第一遍我们只输出每个片元的几何信息——位置、法线、颜色、粗糙度——到多张 G-Buffer 纹理中，并不做光照计算。第二遍再读取这些纹理，逐个像素计算光照。这样做的好处是光照计算的复杂度只与屏幕分辨率有关，与场景中光源的复杂形状无关，可以支持成千上万盏动态光源。

延迟渲染的美妙之处正如画家同时画颜色、法线、材质三张纸，之后在光照阶段“一鼓作气”地综合出最终光影效果——但这也容易让 GPU 填充率（fill rate）成为瓶颈，因为它需要写入多张高分辨率纹理。所以 MRT 虽然提供了强大的并行输出能力，实际使用时依然要权衡显存带宽与画面复杂度。

画家同时画三张纸的妙处在于“一次取景，多角记录”——这不仅是效率提升，更是延迟渲染这类高级光照方案能够落地的基石。

\text{out}_0 = f_0(\text{pos}, \text{uv}); \quad\text{out}_1 = f_1(\text{normal}, \text{uv}); \quad\text{out}_2 = f_2(\text{albedo}, \text{uv})

MRT 的实质是让片元着色器一次计算出多个结果，分别落到不同的颜色附件上——批量化生产，而非一锤子买卖。

多输出声明片元着色器声明多个输出变量，每个输出对应一个颜色附件。
$\text{out}_0, \quad \text{out}_1, \quad \text{out}_2$
输出写入附件每个输出变量被 GPU 自动写入 FBO 的对应颜色附件。
$\text{out}_i \rightarrow \text{GL\_COLOR\_ATTACHMENT}_i$
延迟合成光照阶段逐个像素读取多张纹理，合成最终画面。
$\text{finalColor} = \sum_{\text{lights}} L_i \times \text{albedo} \times f(\text{normal}, \text{pos})$

全流程落地

故事讲到这里，你已经知道了画布是什么、纸有哪几种、怎么挂纸、怎么离屏创作、怎么一次画多张。最后我们把从零到一的全流程串起来，看看一个实际项目中该如何一步步把 FBO 用起来——这就像画家总结出一套完整的作画工序。

第一步，创建 FBO：调用 glGenFramebuffers(1, &fbo) 生成一个 FBO 对象，然后 glBindFramebuffer(GL_FRAMEBUFFER, fbo) 把它绑定为当前绘制目标。第二步，创建并配置附件：生成一张纹理（glGenTextures、glTexImage2D、设置过滤和环绕参数），再调用 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex, 0) 把它挂上去；如果还需要深度测试，就再创建渲染缓冲对象挂到 GL_DEPTH_ATTACHMENT 上。第三步，检查完整性：调用 glCheckFramebufferStatus，若返回值不是 GL_FRAMEBUFFER_COMPLETE 就打印错误，常见原因有附件格式不匹配、尺寸不一致等。第四步，离屏绘制：在 FBO 绑定期间执行所有场景绘制指令，画完后用 glBindFramebuffer(GL_FRAMEBUFFER, 0) 解绑，最后通过 glReadPixels 或采样纹理来读取结果。

在工程上还有几个关键细节：渲染循环中不要每帧创建和销毁 FBO，FBO 本身只是一个骨架，复用它只需要重新绑定不同附件即可；注意视图视口，切换渲染目标后要调用 glViewport 匹配新目标尺寸；用回调函数排查，在使用后处理纹理时可以先将它显示到一个 Debug 窗口中，直观地检查离屏渲染是否正确。性能方面，MRT 会显著增加显存带宽消耗，高分辨率下要注意帧耗；深度纹理（GL_DEPTH_STENCIL）格式在生成时就要设置好，否则深度测试无法工作。

画家的完整工序——铺画布、挑纸、别纸、检查、作画、挂回展厅——与 FBO 的工程流程一一对应。掌握了这一整套流程，你就能在实际项目中灵活自如地处理“画面画好存哪里”的问题了。

\text{glGenFramebuffers} \rightarrow \text{glBindFramebuffer} \rightarrow \text{glFramebufferTexture2D} \rightarrow \text{glCheckFramebufferStatus} \rightarrow \text{draw} \rightarrow \text{glBindFramebuffer}(\text{id}=0)

完整的 FBO 使用流程是一串链条：创建骨架 → 绑定 → 挂纸 → 检查 → 作画 → 回到主画布。哪一环断了，画面都出不来。

创建对象glGenFramebuffers(1, &fbo) 在 GPU 上分配一个 FBO 句柄。
$\text{glGenFramebuffers}(1, \&fbo)$
绑定目标glBindFramebuffer(GL_FRAMEBUFFER, fbo) 让后续绘制写入该 FBO。
$\text{glBindFramebuffer}(\text{target}, \text{fbo})$
挂接附件用 glFramebufferTexture2D 把纹理挂到对应的附件挂载点。
$\text{glFramebufferTexture2D}(\text{target}, \text{attachment}, \text{textype}, \text{texture}, 0)$
完整性检测用 glCheckFramebufferStatus 验证附件组合是否合法。
$\text{glCheckFramebufferStatus}(\text{target}) = \text{GL\_FRAMEBUFFER\_COMPLETE}$
解绑恢复glBindFramebuffer(GL_FRAMEBUFFER, 0) 恢复到默认的屏幕帧缓冲。
$\text{glBindFramebuffer}(\text{target}, 0)$

AI 应用场景

场景一：游戏引擎的实时后处理管线

阶段：推理与渲染优化

解决的问题：游戏场景渲染到屏幕后，直接输出往往显得平淡。传统做法要在 CPU 端逐像素处理颜色，不仅慢，而且无法利用 GPU 并行能力。借助帧缓冲离屏渲染，先将整帧场景渲染到一张纹理上，再通过全屏棋盘格后处理着色器统一做色调映射、泛光、景深模糊，最后才写回默认帧缓冲。

具体案例：在某开放世界手游的渲染管线里，开发团队使用了两个 FBO：一个用于场景主渲染，一个用于后处理模糊链。场景 FBO 的颜色纹理绑定到全屏 Quad 的输入采样器上，后处理输出到屏幕。通过复用 FBO 并仅替换附件纹理，整个后处理链路的帧耗时从 4.2ms 降到了 2.8ms。

场景二：延迟渲染中的 G-Buffer 多目标输出

阶段：特征提取与中间表示

解决的问题：场景中有数百盏动态光源时，传统前向渲染每盏灯都要重画一遍场景，计算量爆炸。延迟渲染通过 MRT 把几何信息（颜色、法线、粗糙度）一次性写入多张 G-Buffer 纹理，光照计算只跑一次全屏 Pass，与光源数量解耦。

具体案例：在自研引擎的阴影与光照系统中，MRT 一次输出 4 张纹理：反照率、法线、金属/粗糙度、深度。光照 Pass 只读取这些纹理聚合计算 PBR 光照，最终用后处理 Pass 合成 HDR 色调映射。这套方案让引擎在移动端支持了 300+ 动态光源而不掉帧。

场景三：AI生成图像的像素级回读

阶段：后处理与数据导出

解决的问题：AI 模型生成图像后，需要把渲染结果保存为 PNG 时，直接读显存可能遇到字节对齐和格式转换问题。利用帧缓冲的 glReadPixels 标准流程，可以将颜色附件中的数据回读到 CPU 内存，再进行格式转换，稳定可靠。

具体案例：在 Stable Diffusion 的高质量放大工具链中，生成结果先在 FBO 离屏渲染到高分辨率纹理，再用 glReadPixels 读回并经过颜色插值、alpha 校正后写出 PNG。这样绕开了 Window 系统自带的 BitBlt 的低效拷贝路径，图像导出效率提升了一倍以上。

Python 演示

python59 行

import numpy as npfrom OpenGL.GL import *from OpenGL.GLUT import * WIDTH, HEIGHT = 256, 256fbo = tex = 0 def create_fbo_texture():    global fbo, tex    tex = glGenTextures(1)    glBindTexture(GL_TEXTURE_2D, tex)    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, WIDTH, HEIGHT, 0,                 GL_RGBA, GL_UNSIGNED_BYTE, None)    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)    fbo = glGenFramebuffers(1)    glBindFramebuffer(GL_FRAMEBUFFER, fbo)    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,                           GL_TEXTURE_2D, tex, 0)    assert glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE    glBindFramebuffer(GL_FRAMEBUFFER, 0) def draw_scene_to_fbo():    glBindFramebuffer(GL_FRAMEBUFFER, fbo)    glViewport(0, 0, WIDTH, HEIGHT)    glClearColor(0.1, 0.2, 0.4, 1.0)    glClear(GL_COLOR_BUFFER_BIT)    glMatrixMode(GL_PROJECTION)    glLoadIdentity()    glOrtho(-1, 1, -1, 1, -1, 1)    glMatrixMode(GL_MODELVIEW)    glLoadIdentity()    glColor3f(1.0, 0.6, 0.2)    glBegin(GL_TRIANGLES)    glVertex2f(-0.5, -0.5)    glVertex2f(0.5, -0.5)    glVertex2f(0.0, 0.5)    glEnd() def read_pixels_from_fbo():    glBindFramebuffer(GL_FRAMEBUFFER, fbo)    data = glReadPixels(0, 0, WIDTH, HEIGHT, GL_RGBA, GL_UNSIGNED_BYTE)    glBindFramebuffer(GL_FRAMEBUFFER, 0)    return np.frombuffer(data, dtype=np.uint8).reshape(HEIGHT, WIDTH, 4) def main():    glutInit()    glutInitDisplayMode(GLUT_RGBA)    glutInitWindowSize(WIDTH, HEIGHT)    glutCreateWindow(b"FBO Demo")    create_fbo_texture()    draw_scene_to_fbo()    pixels = read_pixels_from_fbo()    center = pixels[pixels.shape[0] // 4, pixels.shape[1] // 2]    print("FBO 离屏渲染完成，中心点像素 RGBA:", center)    glutLeaveMainLoop() if __name__ == "__main__":    main()

目的：演示了从 FBO 创建、纹理附件绑定、离屏绘制到像素回读的完整流程，验证“画到纹理里”这一核心概念。

glGenTextures(1)` / `glGenFramebuffers(1)分别向 GPU 申请一张纹理和一个 FBO 骨架的句柄
glTexImage2D(..., None)给纹理分配存储空间但先不填数据，等离屏渲染来写入
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex, 0)把纹理“别”到 FBO 的颜色挂载点上，这是最核心的绑定操作
glBindFramebuffer(GL_FRAMEBUFFER, fbo)切换绘制目标到离屏 FBO，后续画操作写入纹理而非屏幕
glClearColor` + `glClear用背景色清空离屏画布，相当于铺底色
glBegin(GL_TRIANGLES)绘制一个三角形到 FBO 绑定的纹理上
assert glCheckFramebufferStatus(...)验证附件组合是否完整，返回必须等于 GL_FRAMEBUFFER_COMPLETE
glReadPixels(...)从 FBO 的颜色附件中把像素数据读回 CPU 内存，供后续处理
glutLeaveMainLoop()避免进入事件循环，脚本直接退出并打印结果

常见误区

误区我以为帧缓冲是一块直接存储像素的显存区域，和纹理、渲染缓冲没什么本质区别，反正都是存图像的。

正解帧缓冲本身并不存像素，它只是一个“画布骨架”，真正存像素的是挂在它上面的附件。纹理可以当作颜色附件，但它还有采样、滤波等额外能力；渲染缓冲对象则是专门做附件的。你可以把帧缓冲理解为一个文件夹，里面装着一叠纸，每张纸才是真正的内容。

为何常见：因为 API 里“生成帧缓冲”和“生成纹理”语法高度相似，而且日常使用时 FBO 总是和纹理成对出现，让人误以为它们是一类东西。

误区我以为帧缓冲必须同时配置颜色、深度、模板三种附件，否则就“不完整”，不能用来渲染。

正解帧缓冲的完整性取决于你的使用需求。如果后处理阶段不需要深度测试和模板裁剪，完全可以只挂一个颜色附件，glCheckFramebufferStatus 照样返回 GL_FRAMEBUFFER_COMPLETE。只有当你准备开启深度测试时才需要深度附件。完整性检查的核心在于“已挂的附件之间格式和尺寸必须一致”，而不是“所有类型的附件都必须挂齐”。

为何常见：很多教程在讲默认帧缓冲时总是同时提到颜色、深度、模板，因为默认帧缓冲三样都有，但这只是默认帧缓冲的特性，不是自定义 FBO 的硬性要求。

误区我按照教程把场景渲染到 FBO 的纹理上后，以为屏幕上就能看到这张纹理作为结果了，结果屏幕一片黑，以为代码写错了。

正解FBO 离屏渲染的目标是纹理，跟屏幕完全无关。绑定 FBO 之后所有绘制都不输出到屏幕。想要看到画面，你必须把 FBO 解绑（glBindFramebuffer(GL_FRAMEBUFFER, 0)），再对这张纹理做一次全屏绘制（用一个四边形原始体把纹理贴上去），屏幕上的内容才会出现。画到纹理只是“创作”，把纹理展示出来是“展出”，两者是独立的两步。

为何常见：习惯了“直接绘制到屏幕”的人，容易把渲染目标和显示目标混为一谈，忽略了 OpenGL 中“当前绑定谁就画到谁”的机制。

误区我把 FBO 绑定的纹理从 512×512 换成 256×256 的另一个纹理后，直接绘制，画面却出现了裁剪和拉伸，我还以为纹理数据写错了。

正解FBO 只是骨架，重新绑定纹理后，glViewport 仍然保持着旧尺寸。GPU 视口和附件尺寸不匹配时，绘制出来的效果会出现裁剪、比例错误和沿左边缘像素拉伸的问题。正确做法是在切换附件后立即调用 glViewport(0, 0, newWidth, newHeight) 同步视口尺寸。画家换了不同大小的画布，画框的开口也得跟着调整，这是两个必须配合的操作。

为何常见：因为视口是全局状态，不会因为 FBO 绑定变化而自动重设，初学者经常漏掉这一行。

误区我以为 MRT 要创建多个 FBO，每个 FBO 挂一张纹理，然后挨个绘制，这样也能达到多输出的效果。

正解MRT 是一个 FBO 上同时挂多个颜色附件（GL_COLOR_ATTACHMENT0、GL_COLOR_ATTACHMENT1……），片元着色器一次执行就把结果写入所有附件。如果创建多个 FBO，你需要把场景完整地绘制多遍，是串行执行的，不是并行输出。MRT 的核心优势在于“一次光栅化，多个输出”，这就是延迟渲染能大幅提升性能的原因所在。

为何常见：从字面理解“多目标”，很容易联想到“多个 FBO”，但实际定义的“目标”是指同一个 FBO 内的多个颜色挂载点。

面试题

Q1. 帧缓冲（Framebuffer）本身的本质是什么？

单选题 · easy

A.一块直接存储像素颜色的显存区域
B.一个装着多个附件的容器骨架← 正确答案
C.一种用于压缩纹理数据的专用格式
D.一个用于控制顶点变换的硬件单元

答案：B。帧缓冲不直接存储像素，它是一个“画布骨架”，必须挂着颜色、深度、模板等附件才能真正保存数据。A 描述的是附件的功能，C 是压缩纹理，D 是顶点处理阶段，都与帧缓冲的定义不符。

Q2. 帧缓冲中负责记录“哪个物体更靠近相机”的附件是？

单选题 · easy

A.颜色附件
B.模板附件
C.深度附件← 正确答案
D.渲染缓冲附件

答案：C。深度附件为每个像素存储深度值，深度测试通过比较新旧深度来决定覆盖还是丢弃，从而保证靠近相机的物体遮挡后方物体。颜色附件存色值，模板附件管区域裁剪，渲染缓冲只是容器不是功能分类。

Q3. 纹理挂到 FBO 的颜色附件上的 API 调用是？

单选题 · mid

A.glTexImage2D
B.glReadPixels
C.glFramebufferTexture2D← 正确答案
D.glGenFramebuffers

答案：C。glFramebufferTexture2D 将一张 2D 纹理挂到指定附件挂载点，是“把纸别到画布上”的关键步骤。glTexImage2D 只是给纹理分配存储空间，glReadPixels 是把像素读回 CPU，glGenFramebuffers 创建 FBO 骨架。

Q4. 关于渲染缓冲对象（Renderbuffer）的说法正确的是？

单选题 · mid

A.可以被着色器采样读取，实现后处理
B.只能作为附件使用，不能直接被采样← 正确答案
C.内部只能存储模板数据，不能存颜色
D.和纹理一样，需要绑定到纹理单元才能使用

答案：B。渲染缓冲对象是“普通白纸”，只能作为附件供 GPU 写入，无法被采样读取。纹理才是可以采样的“高级纸”。C 错在渲染缓冲可以存储深度、模板或颜色，D 错在它不需要绑定纹理单元。

Q5. 离屏渲染完成后，想要在屏幕上看到纹理内容，必须做什么？

单选题 · mid

A.调用 glReadPixels 把像素读回 CPU 再输出
B.调用 glCopyTexImage2D 把纹理复制到屏幕
C.解绑 FBO 并全屏绘制一次该纹理← 正确答案
D.调用 glDeleteFramebuffers 删除 FBO

答案：C。画到纹理是“幕后创作”，展示是“公开演出”。必须先用 glBindFramebuffer(GL_FRAMEBUFFER, 0) 解绑 FBO，再通过一个全屏四边形把纹理作为输入采样、输出到默认帧缓冲，屏幕才会显示。A 的方式低效且不直接，B 只能复制数据，D 删掉后内容也没了。

Q6. 延迟渲染中 MRT 的核心优势是什么？

单选题 · hard

A.让光源数量不影响光照计算复杂度← 正确答案
B.减少了需要绘制的三角形数量
C.让所有阴影贴图自动共享一份纹理
D.将场景从 3D 自动降维到 2D 平面

答案：A。MRT 将几何信息一次写入多张 G-Buffer 纹理，光照计算仅对每个像素做一次全屏 Pass，复杂度与场景光源数量无关，这就是延迟渲染支持大量动态光源的原因。MRT 不改变几何体数量，不共享阴影贴图，也不做降维操作。

Q7. 以下哪些情况需要检查帧缓冲的完整性？

多选题 · mid

A.创建 FBO 并挂接纹理附件之后← 正确答案
B.附件尺寸与视口尺寸不一致的时候
C.每次重绑不同尺寸的纹理附件后← 正确答案
D.每次调用 glDeleteFramebuffers 之后

答案：AC。完整性检查的目的是确认所有附件的格式、尺寸和组合合法，在刚挂完附件或更换附件后都应当检查。B 中视口尺寸不一致不会导致完整性失败，只会让绘制结果被拉伸；D 中删除 FBO 之后已无对象可查。

Q8. 关于深度测试过程，下列说法正确的有？

多选题 · mid

A.新片元深度小于旧值时，新片元覆盖旧片元← 正确答案
B.新片元深度大于旧值时，新片元保留并覆盖
C.深度值通常存储在深度附件中← 正确答案
D.深度测试的开与关不影响画面遮挡结果

答案：AC。深度值越小表示离相机越近，新片元更近时覆盖旧片元，A 正确。深度附件存储每个像素的深度值，C 正确。B 说反了，新片元更远时应被丢弃。D 错——关闭深度测试会导致后画物体覆盖先画物体，遮挡关系完全错误。

Q9. 关于帧缓冲附件的选择，下列说法正确的是？

多选题 · hard

A.纹理作为颜色附件，后续可以被采样做后处理← 正确答案
B.渲染缓冲对象适合只需写入无需读取的深度附件← 正确答案
C.颜色附件可以使用 glReadPixels 回读像素数据← 正确答案
D.模板附件只能挂纹理，不能挂渲染缓冲

答案：ABC。纹理可被着色器采样，适合后处理，A 正确。渲染缓冲对象不能被采样但写入速度快，适合深度附件，B 正确。颜色附件的像素数据可以通过 glReadPixels 回读到 CPU，C 正确。D 错——模板附件也可以挂渲染缓冲对象，只要存储格式匹配。

Q10. 视口尺寸与 FBO 附件尺寸不一致时，绘制结果会怎样？

单选题 · hard

A.自动重采样，画质无损
B.出现裁剪、拉伸或屏幕边缘异常← 正确答案
C.驱动会自动报错并终止程序
D.帧缓冲完整性检查不会通过

答案：B。视口决定 GPU 光栅化的输出区域，附件决定像素存储位置。两者尺寸不一致时，绘制内容会出现裁剪、比例错误或边界拉伸，但不会自动检查报错。完整性检查只关注附件之间的一致性，与视口无关，所以 D 错。