The Book of Shaders 第 1 章精读:从像素手写到整页印刷——Fragment Shader 与 GPU 并行处理的本质

原创2026-10-14 10:23:171,639 阅读

The Book of Shaders 第 1 章精读:从像素手写到整页印刷——Fragment Shader 与 GPU 并行处理的本质

导读

本文基于 The Book of Shaders 开源仓库第 1 章(01/README-pt.md,即葡萄牙语版 "Começando / O que é um fragment shader?",与英文版 01/README.md 内容一致)展开。本章是全书从"理解"迈向"动手写 shader"的桥梁:先回答"fragment shader 到底是什么",再用"印刷排版"与"流水线"两个比喻讲清 GPU 为什么快、为什么慢,最后点明 GLSL 的地位与 shader 编程的天然约束。读完本文,你将彻底理解位置输入、颜色输出、全像素并行这一 shader 心智模型,并能在仓库中定位到对应的代码示例(如 hello_world.frag、space.frag)作为后续章节的实战起点。

从逐字书写到整页印刷的排版对比图,对应 shader 从"逐像素绘制"到"整屏并行着色"的本质差异

一、fragment shader 是什么:从"逐字写信"到"整页印刷"

第 0 章(00/README.md)把 fragment shader 比作"图形界的古腾堡印刷机"。为什么?第 1 章开篇就给出了答案。

如果你有计算机绘图的经验,你会非常熟悉这样的流程:画一个圆,再画一个矩形、一条线、几个三角形……直到拼出想要的图像。这个过程类似手写一封信或一本书——一条接一条依次执行的指令序列,前一个任务完成,后一个任务才开始。这是典型的串行(serial)思维。

而 shader 完全是另一套逻辑:

  • shader 同样是一组指令(instructions),但这组指令对屏幕上每一个像素同时执行;
  • 因此,你写的代码必须根据像素在屏幕上的位置(position)表现出不同的行为;
  • 你的程序本质上是一个函数:输入一个位置,返回一种颜色;
  • 这个程序一旦被编译,就会以惊人的速度运行——就像一台印刷机,不是一笔一画地抄写,而是把整页内容一次性"压"出来。

中国活字印刷排版图,象征 shader 程序"一次编译、整屏同时着色"的工作方式

这套"函数 = 位置 → 颜色"的心智模型是全书的基石。第 2 章 hello_world.frag 的代码就是最直接的印证:

void main() {
    gl_FragColor = vec4(1.0,0.0,1.0,1.0);
}

这里的 gl_FragColor 是 GLSL 内置的输出变量(写入最终像素颜色),而 main() 正是那个"接收位置、返回颜色"的函数——只不过这个最简单的例子暂时忽略了位置,把画布上所有像素统一染成了同一种颜色(详见 02/README.md 对 GLSL 基础语法的 7 点拆解)。

二、为什么 shader 快:并行处理与 GPU 架构

要回答"为什么快",必须理解并行处理(parallel processing)。

2.1 CPU 的隐喻:工业管道流水线

把 CPU 想象成一根巨大的工业管道,每个任务就像管道中流过的一个工件——宛如一条工厂流水线。有的任务比别的大,需要更多时间和能量(即更高的处理能力)。由于计算机的体系结构,这些任务被迫串行执行:一次只能完成一个。现代计算机通常有一组 4 个这样的处理器(管道),它们一个接一个地完成任务,保持流水线运转。每一根管道,也叫一个线程(thread)。

CPU 管道流水线示意图:任务依次串行通过,对应正文中"线程"的隐喻

2.2 问题规模:逐像素计算的数学压力

游戏和其他图形应用之所以需要远超普通程序的算力,是因为它们要做海量的逐像素(pixel-by-pixel)运算:屏幕上每一个像素都必须被计算,3D 游戏里还要额外计算几何与透视。

把"管道与任务"的隐喻搬回来:屏幕上的每个像素是一个小而简单的任务,单个像素任务对 CPU 来说根本不是问题——但这个微小任务必须对屏幕上每一个像素重复执行!作者在原文中给出了两组震撼的数字:

屏幕规格 每帧像素数 每秒计算量
老式 800×600 屏幕 480,000 像素/帧 14,400,000 次/秒
现代 2880×1800 Retina 屏(60 fps) 5,184,000 像素/帧 311,040,000 次/秒

(注:2880×1800 即 5,184,000 像素,×60 fps = 311,040,000。)这个量级足以压垮任何微处理器。

大批像素数据涌向处理单元的示意图,直观展现逐像素计算带来的吞吐压力

2.3 GPU 的解法:一大堆微型处理器并行工作

这时,并行处理成为最佳方案。与其拥有少数几个又大又强的微处理器(管道),更聪明的做法是拥有大量同时并行运转的微型处理器——这就是图形处理器(Graphics Processor Unit,GPU)。

把微型处理器想象成一张"管道桌",每个像素的数据是一颗乒乓球:

  • 每秒 14,400,000 颗乒乓球足以堵住几乎任何单根管道;
  • 但一张拥有 800×600 个小管道的"桌子",每秒接收 30 波、每波 480,000 颗球,可以轻松处理这股流量;
  • 分辨率更高时道理相同:并行硬件越多,能承载的数据流就越大。

GPU 示意图:大量微型处理器构成的并行阵列,对应正文"管道桌"隐喻

2.4 GPU 的另一个"超能力":硬件加速的数学函数

GPU 的第二个"超能力"是通过硬件加速的特殊数学函数:复杂的数学运算由微芯片直接解析,而不是靠软件模拟。这让三角函数(trigonometric)和矩阵(matrix)运算快到接近电的速度。

这一点在后文章节中有直接体现:03/README.md 明确指出 GLSL 内置了硬件加速的角度、三角函数与指数函数,如 sin()、cos()、tan()、asin()、acos()、atan()、pow()、exp()、log()、sqrt()、abs()、sign()、floor()、ceil()、fract()、mod()、min()、max()、clamp() 等,并给出了用 u_time 配合 sin() 做颜色动画的 time.frag 示例。

三、什么是 GLSL

GLSL 是 OpenGL Shading Language(OpenGL 着色语言)的缩写,是接下来各章节将使用的标准 shader 程序语言。根据硬件与操作系统的不同,还存在其他类型的 shader,但本书统一围绕 OpenGL 规范展开,该规范由 Khronos Group 监管。理解 OpenGL 的历史有助于理解它那些"奇怪"的约定——例如为什么会有 gl_ 前缀的内置变量(gl_FragColor、gl_FragCoord 等),这些约定正是从 OpenGL 传统沿袭下来的。

仓库中 glossary 目录下的 304 个术语条目(如 glossary/gl_FragColor、glossary/gl_FragCoord、glossary/GL_ES)正是为 GLSL 语言各要素准备的逐条解释,可在阅读后续章节时随时查阅。

四、为什么 shader 名声不佳:盲目与无记忆的线程

正如"能力越大,责任越大",并行计算同样遵循这条法则:GPU 强大的架构设计自带限制与约束。理解这些约束,你就理解了为什么初学者会觉得 shader 难写。

4.1 约束一:线程是"盲目"的(blind)

为了并行运行,每个管道(线程)必须独立于其他所有线程。也就是说,线程之间互相"看不见"彼此在做什么:

  • 不可能查看另一个线程的计算结果;
  • 不可能修改输入数据;
  • 不可能把一个线程的结果传递给另一个线程;

允许线程间通信会让数据的完整性(integrity)面临风险。由此推出的铁律是:所有数据只能朝同一个方向流动——从 CPU 流入 GPU,由每个线程只读地消费。这正是第 3 章 03/README.md 引入 uniform 变量的原因:uniform 是 CPU 与 GPU 之间的"小桥",uniform vec2 u_resolution;、uniform vec2 u_mouse;、uniform float u_time; 这类变量对所有线程数值相同(uniform)且只读,每个线程收到同一份数据,可以读但不能改。

4.2 约束二:线程是"无记忆"的(memoryless)

GPU 会让微型处理器始终处于忙碌状态:一旦空闲,立刻接收新信息处理。因此一个线程不可能知道它前一瞬间在做什么——它可能上一刻在画操作系统 UI 的按钮,下一刻在渲染游戏中的一块天空,再下一刻在显示一封邮件的文字。

于是每个线程不仅盲目,而且没有记忆(memoryless)。

4.3 组合拳:为什么 shader 劝退初学者

要编写一个"随像素位置而改变输出"的通用函数,本身就需要相当的抽象能力;再加上"盲目"与"无记忆"的双重限制,shader 因此不太受编程初学者欢迎。但好消息是:

  • 这类约束恰恰是 shader 性能来源——正是因为没有线程间通信、没有状态依赖,GPU 才能把海量线程并行铺满;
  • 后续章节(02、03 等)将一步步从简单到高级地演示如何在这种约束下工作;
  • 如果你用现代浏览器阅读本书,可以直接在页面的交互式代码块上改代码、立即看到效果——仓库的 src 目录(glslCanvas、glslEditor、glslGallery)正是支撑这些交互示例的工具。

4.4 从概念到代码:内建输入输出变量

把抽象概念落回代码,GLSL 在"盲目且无记忆"的世界里为我们准备了两个关键的内建变量:

  • gl_FragColor(输出):默认的像素颜色输出变量,vec4 类型,四个分量对应 R、G、B、A 通道且取值归一化到 0.0 ~ 1.0(见 02/README.md 第 4 点);
  • gl_FragCoord(输入):当前线程正在处理的"像素/屏幕片元"的屏幕坐标。它不是 uniform(因为每个线程取值不同),而是被称为 varying 的变量——这正体现了"位置输入"机制(见 03/README.md 的 gl_FragCoord 小节)。

仓库中的 space.frag 是"用位置决定颜色"的最小范例,代码只有寥寥数行却同时用到上述两个变量:

#ifdef GL_ES
precision mediump float;
#endif

uniform vec2 u_resolution;
uniform vec2 u_mouse;
uniform float u_time;

void main() {
    vec2 st = gl_FragCoord.xy/u_resolution;
    gl_FragColor = vec4(st.x,st.y,0.0,1.0);
}

它把片元坐标除以画布分辨率做归一化,得到 0.0 ~ 1.0 的 st,再直接映射到 R、G 通道——左上角偏黑、右下角偏黄红,直观展示了"同一个函数,因像素位置不同而输出不同颜色"。

五、如何亲手运行这些 shader

本章结尾鼓励读者"点击 Next >> 进入代码"。在动手之前,可以先用第 4 章(04/README.md)介绍的工具链把仓库里的 .frag 文件跑起来,形成"概念 → 代码 → 运行"的闭环:

浏览器方式(glslCanvas):本书所有在线示例都由 glslCanvas 驱动,只需一个 <canvas> 元素即可运行任意 .frag 文件:

<canvas class="glslCanvas" data-fragment-url="yourShader.frag" data-textures="yourInputImage.png" width="500" height="500"></canvas>

命令行方式(glslViewer):可以把 shader 嵌入 bash 脚本或 Unix 管道,用法类似 ImageMagick:

glslViewer yourShader.frag yourInputImage.png -w 500 -h 500 -E screenshot,yourOutputImage.png

此外仓库的 04 目录还提供了 openFrameworks、Processing、SFML、Three.js 等多种框架的接入示例,方便把同一份 shader 代码迁移到你熟悉的平台上。

结语:把"逐像素并行"刻进思维

第 1 章完成了三件事:把 shader 定义为"位置 → 颜色"的函数;用管道与乒乓球两个隐喻解释 GPU 为何能扛住每秒数亿次的像素计算;再用"盲目 + 无记忆"讲清并行架构的代价。这三件事构成了后续所有章节的底层世界观——当你看到 02 的 vec4 与精度声明、03 的 uniform 与 gl_FragCoord 时,它们都是在这个世界观上长出的具体语法。理解了本章,你便掌握了理解整本书(乃至任何 GLSL/WebGL 代码)的第一把钥匙。

登录后查看全文
thebookofshaders